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

[Liam McGillivray]

On Tuesday, 9 April 2024 at 12:45:55 UTC, Richard (Rikki) Andrew 
Cattermole wrote:
>
> On 09/04/2024 12:48 PM, Liam McGillivray wrote:
>
>> I suppose this was a good new thing to learn, though I'm still 
>> quite far from being able to construct a function from another 
>> function using a template.
>> 
>> I suppose that if I wanted it to make a function from another 
>> function, I may be able to do it in a template using some 
>> `static foreach` to make arrays of function parameters, and 
>> then combine them together without the use of strings, instead 
>> using placeholders (aliases or whatever they'd be called) and 
>> maybe the `tupleof` function. Am I headed in the right 
>> direction (if you can understand my weak attempt to describe 
>> the direction I'm thinking of going in)?
>
> ``tupleof`` isn't a function, its a property to get a "tuple" a 
> sequence of fields for a struct/class.
>
> However most likely you'd have to resort to string mixins if 
> you're messing about with parameters like I think? you are 
> asking for.
>
> I'm not entirely sure what you're wanting there.

Here's what I wanted to do.

In the library I'm working on, there are various declarations for 
functions defined in an external C library following the line 
`extern (C) @nogc nothrow:`. Here are some examples of such 
declarations which have a `const(char)*` parameter:
```
void InitWindow(int width, int height, const(char)* title);
void SetWindowTitle(const(char)* title);
Shader LoadShader(const(char)* vsFileName, const(char)* 
fsFileName);
```

I wanted to generate definitions of overloads of these functions 
using strings as parameters instead of `const(char)*`. For the 
`InitWindow` function shown above, the overload should be defined 
like this:
```
void InitWindow(int width, int height, ref string title) {
     InitWindow(width, height, cast(const(char)*)title);
}
```
or alternatively, like the following:
```
void InitWindow(int width, int height, string title) {
     InitWindow(width, height, title.toStringz);
}
```

I'm not sure which of these is better, thought the latter one 
would need to be modified to not accept string literals. I found 
that the former one has the advantage that making the `title` 
parameter `ref string` means that string literals use the 
existing version of the function. I know that the former can be 
`@nogc`, unlike the latter, though I don't know if there is any 
advantage offered by `toStringz` over `cast(const(char)*)`.

But anyway, my goal was to generate function overloads like 
either of the above. I have already posted a version of a CTFE 
function that does this, though I put them under `version 
(D_TypeInfo)` so that they aren't available in `betterC` builds, 
since the function I wrote doesn't build with `betterC`.