"Error: `TypeInfo` cannot be used with -betterC" on a CTFE function

[Liam McGillivray]

I'm making a modification to a D binding for a C library. I made 
a CTFE function which takes a function declaration with one or 
more `const(char)*` or `char*` parameters and makes an overload 
that accepts D strings. While this function is only used during 
compile time, unfortunately, I have found that it results in the 
library no longer supporting `-betterC`. The compiler gives the 
following error.

```
/usr/include/dlang/dmd/core/lifetime.d(2760,42): Error: 
`TypeInfo` cannot be used with -betterC
/usr/include/dlang/dmd/std/utf.d(1556,24):        instantiated 
from here: `_d_newclassT!(UTFException)`
/usr/include/dlang/dmd/std/utf.d(1563,32):        instantiated 
from here: `exception!(const(char)[])`
/usr/include/dlang/dmd/std/utf.d(1186,54):        instantiated 
from here: `decodeImpl!(true, Flag.no, const(char)[])`
/usr/include/dlang/dmd/std/range/primitives.d(2551,18):        
instantiated from here: `decode!(Flag.no, const(char)[])`
/usr/include/dlang/dmd/std/range/primitives.d(178,40):        
instantiated from here: `front!char`
Error /usr/bin/dmd failed with exit code 1.
```

I don't know what part of the function uses `TypeInfo` (as I 
don't really understand what that is), but I know that it is this 
CTFE function causing the error, because commenting out the 
mixins that use it results in the `-betterC` program compiling 
properly. Here is the CTFE function I wrote:

```
string MakeStringOverload(alias func)() {
     string def = ReturnType!func.stringof ~" "~ 
__traits(identifier, func) ~ "(";

     auto paramNames = ParameterIdentifierTuple!func;

     import std.algorithm.searching;
     foreach(i, paramType; Parameters!func) {
         if (paramType.stringof.canFind("char")) def ~= "ref 
string"; // Made a reference so that D string literals know to 
use the base version of the function and not this one.
         else def ~= paramType.stringof;
         def ~= " "~paramNames[i] ~ ", ";
     }
     def.length -= 2;
     def ~= ") { ";
     if (ReturnType!func.stringof != "void") def ~= "return ";
     def ~= __traits(identifier, func) ~ "(";
     foreach(i, argument; paramNames) {
         if (Parameters!func[i].stringof.canFind("char")) def ~= 
"cast(char*)";
         def ~= argument ~ ", ";
     }
     def.length -= 2;
     def ~= "); }";

     return def;
}
```

In the module where the base versions of functions are declared, 
I do the following to generate overloads:
```
mixin(MakeStringOverload!SetWindowTitle);
mixin(MakeStringOverload!LoadShader);
mixin(MakeStringOverload!LoadShaderFromMemory);
mixin(MakeStringOverload!GetShaderLocation);
```

So what part of my function is using "TypeInfo"? Can I somehow 
label my function as compile-time only so that it stops 
complaining? If not what else can I do to get it to stop 
complaining and compile with `betterC`?