Is there a way of constructing function pointer types using Reflection?

[jgh07]

I need some way of constructing a function pointer type that points to a specific function signature. So something like this:

Type[] args = [typeof(int), typeof(int)];
// Pointer to (int -> int) method
Type functionPointerType = typeof(delegate*<>).MakeGenericType(args);

The above sadly does not work, as the type arguments for delegate*<> need to be fully specified. I looked through the documentation and could not find anything regarding this.

A more specific example, how would I use System.Reflection.Emit to create a field such as this:

.field public method int32 *(int32) function

[Clockwork-Muse]

..... why? What problem are you trying to solve where you need to find this information at runtime?
And why a function pointer, as opposed to Func<int int>?

[jgh07]

I am making a small compiler for my custom .NET language. As such, I would like to support as many CLR features as possible. Regular delegates are already supported, as is interacting with function pointers defined in external assemblies. The only thing missing is the creation of strongly-typed function pointers.

So far I have been using an ugly hack based around representing the function pointer as a native int32, but that only works in limited scenarios.

So the actual problem I'm trying to solve is quite literally exactly that - creating a field using Reflection.Emit whose type is a function pointer.

[Clockwork-Muse]

Is part of the exercise actually writing your own compiler, or is it the development of the language?
What I'm getting at is, if the exercise isn't to write your own (complete) compiler, you should be using/extending Roslyn, which would obviate the need to use reflection.

For that matter, you'd likely have a better time with source generators.

[jgh07]

I'm trying to write the compiler "from scratch". This is really the first major headache I've ran into regarding System.Reflection.Emit, as I am starting to think this might be more complicated than I thought. Because as it turns out, not even loading existing fields of method pointers works as expected. One thought I had was to construct the underlying type handle myself and to inject that into the IL bytes directly, but I'm not too sure how feasible that is.

Hope I'm overseeing something and it's actually possible somehow.

[davidfowl]

Maybe use Mono.Cecil instead?

[jgh07]

There seem to be concrete plans of adding my requested features, so I think I'll wait it out.

[huoyaoyuan]

Reflection support isn't complete for function pointer. Inspection for function pointer type was added in .NET 8, but creation of function pointer isn't. There are also other features like static virtual methods that are not supported by reflection.