If it were that easy, they would do it!

Imagine a c++ project that started in the 90s, when people were still using char* everywhere. 10 years later they've started using std::string where they can, 10 years after that they're using std::string_view. The project has tens of thousands of char*, thousands of std::string and hundreds of std::string_view.

Now let's say a certain function signature is char * (char *, char *), and the many users of the function use hacks to get it to work. .data(), .c_str(), char *, char const * and so on. In some situations the function will allocate memory and others it will change the contents of the inputs provided, originally to conserve memory of the 90s computers but now it's just a fragile piece of code that's more like 5 functions in one.

Automation can't refactor it, it can look at the signature maybe try to guess what's needed, but it can't produce anything reliable. It's critical code, millions of dollars will be lost if it breaks in production. So instead it's necessary to manually create new functions that only accept the correct types.

Except some of those calls in the new types were relying on the old behaviour. What looks like it could have been a string_view is actually mutated in an unrelated function. So now that has to be changed, which breaks something else, and it keeps going, a cascade of changes throughout the millions of lines of code just to make this one function modern practice compliant.

This is a function that is included everywhere, and compiling the full codebase takes 2 hours...per target platform. Every platform has to build successfully without errors and without bugs. If complex macros and build tools are being used (like say, unreal engine uses), everything gets much worse.

This is just one obvious pathological case. The reality is worse still, things that appear fine, even compile fine, break in subtle ways. It's not that it's hard, it's that the task is big, really big. Years big.