Add function pointer support for managed instance methods

[steveharter]

Currently only managed static methods are supported.

Besides the obvious feature benefit of supporting instance methods, this feature would help with re-use of a signature across different types and methods including using "System.Object" for all reference types:

public class TestClass1
{
    public TestClass1 SomeMethod => this; // We want to return a reference type; just return 'this'.
}

public class TestClass2
{
    public TestClass2 SomeMethod=> this;
}

internal unsafe class Program
{
    static void Main()
    {
        // Common signature that takes a reference type as "this" and returns a reference type.
        // Note the use of the 'instance' keyword.
        delegate* instance<object, object> fObjectObject;

        {
            IntPtr fp = typeof(TestClass1).GetMethod("get_SomeMethod").MethodHandle.GetFunctionPointer();
            fObjectObject = (delegate* instance<object, object>)fp;
            TestClass1 ret = (TestClass1)fObjectObject(new TestClass1());
        }

        {
            IntPtr fp = typeof(TestClass2).GetMethod("get_SomeMethod").MethodHandle.GetFunctionPointer();
            fObjectObject = (delegate* instance<object, object>)fp;
            TestClass2 ret = (TestClass2)fObjectObject(new TestClass2());
        }
    }
}

This feature would be leveraged by reflection invoke as a fast path that avoids emit (where reflection creates and jits expensive DynamicMethods) for common cases by re-using hard-coded function pointer signatures that would help with startup and warmup performance.

The original function pointer proposal at https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/function-pointers.md#allow-instance-methods discussed this feature; some snippets:

• The proposal could be extended to support instance methods by taking advantage of the EXPLICITTHIS CLI calling convention (named instance in C# code).
• Function pointers which differed by the calling convention instance and managed would be incompatible even though both cases are used to invoke managed methods with the same C# signature.
  • That link mentions a "workaround" mentioned of adding a static local function, however, that is only applicable if the code is owned, and not for the more general case such as use by reflection invoke.

[timcassell]

#7331