BadImageFormatException thrown on ldftn opcode with interface method since .NET Core 3.0

[epeshk]

Since .NET Core 3.0 ldftn opcode can't be used with interface methods (probably due to default implementations-related changes). Following code works on .NET Framework & .NET Core 2.x, but fails on .NET Core 3.0-3.1. Tested on Windows x64.

using System;
using System.Reflection;
using System.Reflection.Emit;

namespace Repro
{
    public interface IA
    {
        void X();
    }
    public class A : IA
    {
        public void X() => Console.WriteLine("!");
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            var assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("Repro"), AssemblyBuilderAccess.Run);
            var module = assembly.DefineDynamicModule("module");
            var typeBuilder = module.DefineType(
            	"Type", 
            	TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.Public);
            var method = typeBuilder.DefineMethod(
            	"Method",
            	MethodAttributes.Static | MethodAttributes.Public,
            	typeof(Action<IA>),
            	Type.EmptyTypes);

            var il = method.GetILGenerator();
            il.Emit(OpCodes.Ldnull);
            il.Emit(OpCodes.Ldftn, typeof(IA).GetMethod(nameof(IA.X)));
            il.Emit(OpCodes.Newobj, typeof(Action<IA>).GetConstructor(new[]{typeof(object), typeof(IntPtr)}));
            il.Emit(OpCodes.Ret);
            
            var type = typeBuilder.CreateType();
            
            var methodInfo = type.GetMethod(method.Name, BindingFlags.Static|BindingFlags.Public);

            var callable = (Func<Action<IA>>) methodInfo.CreateDelegate(typeof(Func<Action<IA>>));
            callable()(new A());
        }
    }
}

Without manual code generation, this instruction could be obtained from C++/CLI compiler.

public interface struct IA
{
	void X();
};

public ref struct A : IA
{
	static initonly Action<IA^>^ XAction = gcnew Action<IA^>(&IA::X);
	virtual void X() {
		Console::WriteLine("!");
	}
};

In this case, BadImageFormatException will be thrown from A static constructor.

[jeffschwMSFT]

cc @MichalStrehovsky

[MichalStrehovsky]

I made sure to preserve the legacy behavior in the original implementation of default interface methods (it was possible to keep it), but the C# compiler team requested that we do a conscious breaking change here. dotnet/coreclr#23032 was the breaking change. See the linked issue.

Cc @AlekseyTs

[davidwrighton]

Support for the ldftn opcode in combination with an interface method and a null object parameter that was then passed to a delegate constructor was an extension to the ECMA 335 specification which the .NET runtime no longer supports. However, it is still possible to construct such delegates through reflection.