BadImageFormatException when invoking static abstract method through reflection

[wallymathieu]

Description

Write generic code to work around that you can't get a static reference to a static method. Since you can cache the reflected instance or use roslyn generator some these limitations have workarounds. However, what we have found is that trying to invoke the static abstract interface method by fetching the method using reflection and then invoking it causes BadImageFormatException to be thrown.

Reproduction Steps

From dotnet/fsharp#14391 (comment)

namespace Foo
{
    class C
    {
        public interface IFoo<T> where T : IFoo<T>
        {
            static abstract int A();
            abstract int B();
        }

        public struct Foo : IFoo<Foo>
        {
            public static int A() { return 2; }
            public int B() { return 3; }
        }

        public static int Main(string[] _)
        {
            var foo = new Foo();
            var x = typeof(Foo).GetInterface("IFoo`1").GetMethod("B").Invoke(foo, null);
            System.Console.WriteLine(x);
            var y = typeof(Foo).GetInterface("IFoo`1").GetMethod("A").Invoke(null, null);
            System.Console.WriteLine(y);
            /* Throws
            System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation.
             ---> System.BadImageFormatException: Bad IL format.
               at Foo.C.IFoo`1.A()
               at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
               --- End of inner exception stack trace ---
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
               at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
               at Foo.C.Main(String[] _)
               at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
             */
            return 0;
        }
    }
}

Expected behavior

The expected behaviour would be to match the behaviour of regular instance methods on interfaces (you can invoke them through reflection).

Actual behavior

Instead of being able to call the method we get a BadImageFormatException saying that it is Bad IL format:

            System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation.
             ---> System.BadImageFormatException: Bad IL format.
               at Foo.C.IFoo`1.A()
               at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
               --- End of inner exception stack trace ---
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)
               at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
               at Foo.C.Main(String[] _)
               at System.RuntimeMethodHandle.InvokeMethod(Object target, Void** arguments, Signature sig, Boolean isConstructor)
               at System.Reflection.MethodInvoker.Invoke(Object obj, IntPtr* args, BindingFlags invokeAttr)

Regression?

This is a new feature in .net.

Known Workarounds

The workaround is to not use the feature (i.e. use a dummy instance and instance interface methods).

Configuration

Operating system (Windows Appveyor Visual Studio 2022 image, Mac OS X, GitHub Ubuntu latest (2022-11) )
.NET Runtime kind (.NET 7.0.100)

Other information

Originally tracked as issue on F# but then found out that it is not F# specific.

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[MichalStrehovsky]

Cc @trylek for static abstracts

[danmoseley]

I just hit this. Smaller repro:

using System.Numerics;

internal class Program
{
    private static void Main(string[] args) =>Test(long.MaxValue);

    static void Test<T>(T value) where T : INumber<T>
    {
        Console.WriteLine(value > T.Zero); // put breakpoint here and evaluate "value > T.Zero" in the immediate window
    }
}

In the immediate window, I get

value > T.Zero
'value > T.Zero' threw an exception of type 'System.BadImageFormatException'
    Data: {System.Collections.ListDictionaryInternal}
    FileName: null
    FusionLog: null
    HResult: -2147024885
    HelpLink: null
    InnerException: null
    Message: "Bad IL format."
    Source: "System.Private.CoreLib"
    StackTrace: "   at System.Numerics.INumberBase`1.get_Zero()"
    TargetSite: {TSelf get_Zero()}

This is with 17.4.3. It occurs whether targeting 7.0 or 8.0.

It is an impediment when debugging code written to use the new generic math features (cc @tannergooding )

[vitek-karas]

I think this is a bit more complicated than a simple bug.

Take this as an example:

public class C {
    public static void Main() {
        // A
        typeof(Foo).GetInterface("IFoo`1").GetMethod("DoIt").Invoke(null, new object[] {});
        
        // B
        Console.WriteLine(typeof(Foo).GetInterface("IFoo`1") == typeof(IFoo<string>));
        typeof(IFoo<string>).GetMethod("DoIt").Invoke(null, new object[] {});
        
        // C
        typeof(Foo).GetMethod("Test").Invoke(new MyFoo(), new object [] {});
    }
    
    public interface IFoo<T> { static abstract void DoIt(); }
    
    public abstract class Foo : IFoo<string> {
        public static void DoIt() {}
        
        public abstract void Test();
    }
    
    public class MyFoo : Foo
    {
        public override void Test() { Console.WriteLine("test"); }
    }
}

A is basically a repro from this issue. It throws.

B shows that it needs to behave the same as A. Meaning the GetInterface call can only return IFoo<string> type and nothing more (otherwise it would effectively break existing API beahviors). But calling the abstract static method on IFoo<string> should obviously fail - since there's no implementation on the interface and there's no way to tell which implementation to use.

C is how this works for instance abstract methods - it's possible to invoke them, but only because the implementation is resolved by looking at the actual type of the object passed as the instance to the Invoke method. In this case the new MyFoo().

But there's no such thing for static methods - they must have the instance parameter null. And so there's no way to tell the Invoke API how to resolve the implementation. In normal code this is done via constrains. The call instruction is actually a constrained call where the constraint specify the type with the implementation. But reflection doesn't have an API to do this.

I'm no aware of an API which could do this today - I think we basically need a new API - or some new pattern which doesn't work currently.

[wallymathieu]

So having another exception in the static interface case that tells you to use another API would be more helpful. Bad image format exception does not feel very helpful.

[vitek-karas]

@wallymathieu absolutely agree that the exception should be different. But I think the bigger point is that there's probably no API to do this today. The only workaround I could think of is to manually implement the method implementation resolution - so find the matching implementation method in Foo for the IFoo<T>.DoIt - which is what the possibly new reflection API should do for you.

[svick]

Isn't GetInterfaceMap() sufficient? For example, the following code works:

typeof(Foo).GetInterfaceMap(typeof(IFoo<string>)).TargetMethods[0].Invoke(null, new object[0]);

Though finding the right method from among the TargetMethods is not particularly convenient, which is why new API could still be useful.

[vitek-karas]

I agree that the method resolution isn't crazy complex. I still think it would be better to have a reflection API for this so that we can maintain that it matches the runtime behavior even going forward.

[Joe4evr]

@svick GetInterfaceMap is also bugged for interfaces containing static abstract members: #73658