[RuntimeAsync] MethodInfo.GetMethodBody fails with AF:MayHaveILHeader()

[jkotas]

Repro

Compile and run with runtime async enabled:

using System.Threading.Tasks;

public class Test
{
   static void Main() {
        typeof(Test).GetMethod("M").GetMethodBody();
   }

   public async Task M() {
       await Task.Delay(1);
   }
}

Result

Assert failure(PID 38644 [0x000096f4], Thread: 39468 [0x9a2c]): Precondition failure:
FAILED: MayHaveILHeader()

[jkotas]

cc @VSadov

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-reflection
See info in area-owners.md if you want to be subscribed.

[VSadov]

This is a scenario where reflection sees a Task-returning variant. Its signature matches the signature in the metadata, which is desirable, but its body is a thunk. (the IL body does not even return a Task, it actually returns void. In a way the IL is a "blueprint" for a method that could return Task)

For the internal purposes the IL body belongs to the async variant, which is invisible to reflection. And the body for the Task-returning variant is an implementation detail provided by the runtime. Introspecting implementation details is, at best, useless to the user.

It is an interesting puzzle what public API GetMethodBody should return for this case.
Perhaps for public introspection purposes we should specialcase async variants and return the result that matches the body that was in the IL.

[jkotas]

Yes, I think we should return the actual IL method body here. Users can consult MethodImplementationFlags to figure out that the method body is runtime async. This API should be symmetric with Reflection.Emit where we allow emitting runtime async body accompanied with MethodImplAttributes.Async.

[VSadov]

Something possibly related - when something crashes, the stack trace includes both variants at points when we enter/exit runtime async call chain. It is technically correct because one variant calls another at the edges, but to the user it looks like duplicated frames.

Perhaps we should hide the async variants when printing or introspecting the stack.