Reflection Invoke does not check ContainsGenericParameters

[Suchiman]

    class Program
    {
        static void Main(string[] args)
        {
            var m = typeof(SimpleType).GetMethod("GenericMethod");
            //m = m.MakeGenericMethod(typeof(string));
            m.Invoke(new SimpleType(), new object[0]);
        }
    }

    class SimpleType
    {
        public void GenericMethod<T>() { }
    }

Expected Behavior:
Throws

Unhandled exception. System.InvalidOperationException: Late bound operations cannot be performed on types or methods for which ContainsGenericParameters is true.
   at System.Reflection.RuntimeMethodInfo.ThrowNoInvokeException()
   at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   at System.Reflection.MethodBase.Invoke(Object obj, Object[] parameters)
   at Program.Main(String[] args)

Actual Behavior:
Throws

Unhandled exception. System.NotSupportedException: This object cannot be invoked because no code was generated for it: 'SimpleType.GenericMethod()'.
   at System.Reflection.Runtime.MethodInfos.RuntimeNamedMethodInfo`1.GetUncachedMethodInvoker(RuntimeTypeInfo[], MemberInfo) + 0x2f
   at System.Reflection.Runtime.MethodInfos.RuntimeMethodInfo.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) + 0x2b
   at Program.Main(String[] args) + 0x59

[MichalStrehovsky]

We can probably follow dotnet/runtimelab#858 and add that check there too.

[hez2010]

I don't think this should be fixed in this way.
The class SimpleType definitely can contain a method without any generic parameter public void GenericMethod() { }, and this method may be trimmed during compilation and cause MissingRuntimeArtifactException.

[MichalStrehovsky]

If a non-generic method gets completely trimmed away, we don't throw an exception; the reflection stack acts as if it was never there.

Try:

using System;

class Program
{
    static Type programType = typeof(Program);
    static string unusedMethodString = "UnusedMethod";

    public static void UnusedMethod() => Console.WriteLine("Hello");

    static void Main()
    {
        programType.GetMethod(unusedMethodString).Invoke(null, Array.Empty<object>());
    }
}

This will throw a NullReferenceException (with trimming enabled) because UnusedMethod got trimmed.

You will also get a compile-time warning that there's a problem:

C:\git\runtime\src\coreclr\tools\aot\ILCompiler\repro\Program.cs(12): Trim analysis warning IL2080: Program.Main(): 'this' argument does not satisfy 'DynamicallyAccessedMemberTypes.PublicMethods' in call to 'System.Type.GetMethod(String)'. The field 'Program.programType' does not have matching annotations. The source value must declare at least the same requirements as those declared on the target location it is assigned to.

(You need to opt into the warning with <SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings> because they're suppressed by default - we're hoping to change the default in .NET 6).

(If you change the above program to not use static fields, the compiler can actually figure this reflection out and there will be no warnings.)

The fix I proposed won't change this experience.

[Suchiman]

Still reproduces on .NET 9.0 daily builds, should probably be moved to dotnet/runtime now