First part of async support in native AOT

Following works with runtime async enabled in Roslyn on native AOT:

```csharp
public class Async2Void
{
    public static void Main()
    {
        var t = AsyncTestEntryPoint(123, 456);
        t.Wait();
        Console.WriteLine(t.Result);
    }

    private static async Task<int> AsyncTestEntryPoint(int x, int y)
    {
        int result = await OtherAsync(x, y);
        return result;
    }

    private static async Task<int> OtherAsync(int x, int y)
    {
        Console.WriteLine(x);
        Console.WriteLine(y);
        return x + y;
    }
}
```

The implementation strategy is as follows:

* In the compiler, whenever someone holds an `EcmaMethod` of a asyncv2 method, it means they're holding the `RuntimeAsync` flavor of the method (in CoreCLR VM parlance). The return value is a `Task`, `MethodDesc.IsAsync` is true, `MethodSignature.IsAsyncCallConv` is false. The IL is a thunk to the `AsyncVariantImplMethod` flavor.
* In the compiler, we have a new `MethodDesc` descendant: `AsyncVariantImplMethod`. This is the actual method with async calling convention that corresponds to some `EcmaMethod` with `IsAsync`==true. For this one: the return value is unwrapped from `Task`, `MethodDesc.IsAsync` is true, `MethodSignature.IsAsyncCallConv` is true. The IL is the actual IL that corresponds to the wrapped `EcmaMethod` on disk.

Author: MichalStrehovsky

src/coreclr/tools/Common/Compiler/AsyncVariantImplMethod.Mangling.cs

@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Internal.TypeSystem;
+
+using Debug = System.Diagnostics.Debug;
+
+namespace ILCompiler
+{
+    public partial class AsyncVariantImplMethod : MethodDelegator, IPrefixMangledMethod
+    {
+        MethodDesc IPrefixMangledMethod.BaseMethod => _wrappedMethod;
+
+        string IPrefixMangledMethod.Prefix => "AsyncCallable";
+    }
+}

src/coreclr/tools/Common/Compiler/AsyncVariantImplMethod.Sorting.cs

@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Internal.TypeSystem;
+
+using Debug = System.Diagnostics.Debug;
+
+namespace ILCompiler
+{
+    public partial class AsyncVariantImplMethod : MethodDelegator
+    {
+        protected override int ClassCode => 0xfa6c81;
+        protected override int CompareToImpl(MethodDesc other, TypeSystemComparer comparer)
+        {
+            return comparer.Compare(_wrappedMethod, ((AsyncVariantImplMethod)other)._wrappedMethod);
+        }
+    }
+}

src/coreclr/tools/Common/Compiler/AsyncVariantImplMethod.cs

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+using Debug = System.Diagnostics.Debug;
+
+namespace ILCompiler
+{
+    /// <summary>
+    /// Represents an async method callable with <see cref="MethodSignatureFlags.AsyncCallConv"/> calling convention.
+    /// The IL method body for this method comes from <see cref="MetadataDefinition"/> method that was provided in the constructor
+    /// (typically, from user provided assemblies). This MethodDesc corresponds to AsyncVariantImpl in the CoreCLR VM parlance.
+    /// The difference between this method and the method provided in the constructor to this class is that: method signature
+    /// unwraps Task parameters and the calling convention changes to async.
+    /// </summary>
+    public partial class AsyncVariantImplMethod : MethodDelegator
+    {
+        private MethodSignature _signature;
+
+        public EcmaMethod MetadataDefinition => (EcmaMethod)_wrappedMethod;
+
+        public AsyncVariantImplMethod(EcmaMethod wrappedMethod)
+            : base(wrappedMethod)
+        {
+            Debug.Assert(wrappedMethod.IsAsync);
+            Debug.Assert(wrappedMethod.IsTaskReturning());
+            Debug.Assert(wrappedMethod.IsTypicalMethodDefinition);
+        }
+
+        private MethodSignature InitializeSignature()
+        {
+            MethodSignature sig = _wrappedMethod.Signature;
+            MethodSignatureBuilder builder = new MethodSignatureBuilder(sig);
+            TypeDesc returnType = sig.ReturnType;
+            builder.ReturnType = returnType.HasInstantiation ? returnType.Instantiation[0] : Context.GetWellKnownType(WellKnownType.Void);
+
+            Debug.Assert((_wrappedMethod.Signature.Flags & MethodSignatureFlags.AsyncCallConv) == 0);
+            builder.Flags = sig.Flags | MethodSignatureFlags.AsyncCallConv;
+
+            return _signature = builder.ToSignature();
+        }
+
+        public override MethodSignature Signature => _signature ?? InitializeSignature();
+
+        public override MethodDesc GetMethodDefinition() => this;
+        public override MethodDesc GetTypicalMethodDefinition() => this;
+
+        public override MethodDesc GetCanonMethodTarget(CanonicalFormKind kind)
+        {
+            // We should not be calling GetCanonMethodTarget on generic definitions of anything
+            // and this MethodDesc is a generic definition.
+            Debug.Assert(!HasInstantiation && !OwningType.HasInstantiation);
+            return this;
+        }
+
+        public override MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation) => throw new NotImplementedException();
+    }
+}

src/coreclr/tools/Common/Compiler/CompilerTypeSystemContext.Async.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.IL;
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+using Debug = System.Diagnostics.Debug;
+
+namespace ILCompiler
+{
+    public partial class CompilerTypeSystemContext
+    {
+        public MethodDesc GetAsyncVariantImplMethod(MethodDesc asyncMetadataMethod)
+        {
+            MethodDesc asyncMetadataMethodDef = asyncMetadataMethod.GetTypicalMethodDefinition();
+            MethodDesc result = _asyncVariantImplHashtable.GetOrCreateValue((EcmaMethod)asyncMetadataMethodDef);
+
+            if (asyncMetadataMethodDef != asyncMetadataMethod)
+            {
+                TypeDesc owningType = asyncMetadataMethod.OwningType;
+                if (owningType.HasInstantiation)
+                    result = GetMethodForInstantiatedType(result, (InstantiatedType)owningType);
+
+                if (asyncMetadataMethod.HasInstantiation)
+                    result = GetInstantiatedMethod(result, asyncMetadataMethod.Instantiation);
+            }
+
+            return result;
+        }
+
+        private sealed class AsyncVariantImplHashtable : LockFreeReaderHashtable<EcmaMethod, AsyncVariantImplMethod>
+        {
+            protected override int GetKeyHashCode(EcmaMethod key) => key.GetHashCode();
+            protected override int GetValueHashCode(AsyncVariantImplMethod value) => value.MetadataDefinition.GetHashCode();
+            protected override bool CompareKeyToValue(EcmaMethod key, AsyncVariantImplMethod value) => key == value.MetadataDefinition;
+            protected override bool CompareValueToValue(AsyncVariantImplMethod value1, AsyncVariantImplMethod value2)
+                => value1.MetadataDefinition == value2.MetadataDefinition;
+            protected override AsyncVariantImplMethod CreateValueFromKey(EcmaMethod key) => new AsyncVariantImplMethod(key);
+        }
+        private AsyncVariantImplHashtable _asyncVariantImplHashtable = new AsyncVariantImplHashtable();
+    }
+}

src/coreclr/tools/Common/Compiler/MethodExtensions.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
+
 using ILCompiler.DependencyAnalysis;
 
 using Internal.TypeSystem;
@@ -77,6 +79,27 @@ public static string GetUnmanagedCallersOnlyExportName(this EcmaMethod This)
             return null;
         }
 
+        /// <summary>
+        /// Returns true if the method returns Task, Task&lt;T&gt;, ValueTask, or ValueTask&lt;T&gt;, otherwise false.
+        /// </summary>
+        public static bool IsTaskReturning(this MethodDesc method)
+        {
+            TypeDesc ret = method.GetTypicalMethodDefinition().Signature.ReturnType;
+
+            if (ret is MetadataType md
+                && md.Module == method.Context.SystemModule
+                && md.Namespace.SequenceEqual("System.Threading.Tasks"u8))
+            {
+                ReadOnlySpan<byte> name = md.Name;
+                if (name.SequenceEqual("Task"u8) || name.SequenceEqual("Task`1"u8)
+                    || name.SequenceEqual("ValueTask"u8) || name.SequenceEqual("ValueTask`1"u8))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
 #if !READYTORUN
         /// <summary>
         /// Determine whether a method can go into the sealed vtable of a type. Such method must be a sealed virtual

src/coreclr/tools/Common/JitInterface/AsyncMethodDesc.cs

@@ -3,6 +3,9 @@
 
 using System;
 using System.Diagnostics;
+
+using ILCompiler;
+
 using Internal.TypeSystem;
 
 namespace Internal.JitInterface
@@ -82,28 +85,4 @@ public override MethodSignature Signature
         int IJitHashableOnly.GetJitVisibleHashCode() => _jitVisibleHashCode;
 #endif
     }
-
-    internal static class AsyncMethodDescExtensions
-    {
-        /// <summary>
-        /// Returns true if the method returns Task, Task&lt;T&gt;, ValueTask, or ValueTask&lt;T&gt;, otherwise false.
-        /// </summary>
-        public static bool IsTaskReturning(this MethodDesc method)
-        {
-            TypeDesc ret = method.GetTypicalMethodDefinition().Signature.ReturnType;
-
-            if (ret is MetadataType md
-                && md.Module == method.Context.SystemModule
-                && md.Namespace.SequenceEqual("System.Threading.Tasks"u8))
-            {
-                ReadOnlySpan<byte> name = md.Name;
-                if (name.SequenceEqual("Task"u8) || name.SequenceEqual("Task`1"u8)
-                    || name.SequenceEqual("ValueTask"u8) || name.SequenceEqual("ValueTask`1"u8))
-                {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
 }

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -877,6 +877,7 @@ private void Get_CORINFO_SIG_INFO(MethodSignature signature, CORINFO_SIG_INFO* s
 
             if (!signature.IsStatic) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_HASTHIS;
             if (signature.IsExplicitThis) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_EXPLICITTHIS;
+            if (signature.IsAsyncCallConv) sig->callConv |= CorInfoCallConv.CORINFO_CALLCONV_ASYNCCALL;
 
             TypeDesc returnType = signature.ReturnType;
 
@@ -1827,11 +1828,6 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
 
             if (result is MethodDesc method)
             {
-                pResolvedToken.hMethod = ObjectToHandle(method);
-
-                TypeDesc owningClass = method.OwningType;
-                pResolvedToken.hClass = ObjectToHandle(owningClass);
-
 #if !SUPPORT_JIT
                 _compilation.TypeSystemContext.EnsureLoadableMethod(method);
 #endif
@@ -1847,6 +1843,34 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
 #else
                 _compilation.NodeFactory.MetadataManager.GetDependenciesDueToAccess(ref _additionalDependencies, _compilation.NodeFactory, (MethodIL)methodIL, method);
 #endif
+
+                if (pResolvedToken.tokenType == CorInfoTokenKind.CORINFO_TOKENKIND_Await)
+                {
+                    Debug.Assert(method.IsAsync);
+
+#if !READYTORUN
+                    // in rare cases a method that returns Task is not actually TaskReturning (i.e. returns T).
+                    // we cannot resolve to an Async variant in such case.
+                    // return NULL, so that caller would re-resolve as a regular method call
+                    method = method.IsTaskReturning()
+                        ? _compilation.TypeSystemContext.GetAsyncVariantImplMethod(method)
+                        : null;
+#else
+                    // Above ifdef might be usable as-is, but GetAsyncVariantImplMethod is currently not part of the project
+                    throw new NotImplementedException();
+#endif
+                }
+
+                if (method != null)
+                {
+                    pResolvedToken.hMethod = ObjectToHandle(method);
+                    pResolvedToken.hClass = ObjectToHandle(method.OwningType);
+                }
+                else
+                {
+                    pResolvedToken.hMethod = null;
+                    pResolvedToken.hClass = null;
+                }
             }
             else
             if (result is FieldDesc)
@@ -4315,7 +4339,7 @@ private uint getJitFlags(ref CORJIT_FLAGS flags, uint sizeInBytes)
                 flags.Set(CorJitFlag.CORJIT_FLAG_SOFTFP_ABI);
             }
 
-            if (this.MethodBeingCompiled.IsAsync)
+            if (this.MethodBeingCompiled.Signature.IsAsyncCallConv)
             {
                 flags.Set(CorJitFlag.CORJIT_FLAG_ASYNC);
             }

src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs

@@ -377,6 +377,7 @@ public enum CorInfoCallConv
         CORINFO_CALLCONV_HASTHIS = 0x20,
         CORINFO_CALLCONV_EXPLICITTHIS = 0x40,
         CORINFO_CALLCONV_PARAMTYPE = 0x80,     // Passed last. Same as CORINFO_GENERICS_CTXT_FROM_PARAMTYPEARG
+        CORINFO_CALLCONV_ASYNCCALL = 0x100,    // Is this a call to an async function?
     }
 
     // Represents the calling conventions supported with the extensible calling convention syntax
@@ -1364,6 +1365,9 @@ public enum CorInfoTokenKind
 
         // token comes from resolved static virtual method
         CORINFO_TOKENKIND_ResolvedStaticVirtualMethod = 0x1000 | CORINFO_TOKENKIND_Method,
+
+        // token comes from runtime async awaiting pattern
+        CORINFO_TOKENKIND_Await = 0x2000 | CORINFO_TOKENKIND_Method,
     };
 
     // These are error codes returned by CompileMethod

src/coreclr/tools/Common/TypeSystem/IL/NativeAotILProvider.cs

@@ -3,6 +3,8 @@
 
 using System;
 
+using ILCompiler;
+
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
 
@@ -309,6 +311,20 @@ public override MethodIL GetMethodIL(MethodDesc method)
                         return result;
                 }
 
+                if (ecmaMethod.IsAsync)
+                {
+                    if (ecmaMethod.IsTaskReturning())
+                    {
+                        return AsyncThunkILEmitter.EmitTaskReturningThunk(ecmaMethod, ((CompilerTypeSystemContext)ecmaMethod.Context).GetAsyncVariantImplMethod(ecmaMethod));
+                    }
+                    else
+                    {
+                        // We only allow non-Task returning runtime async methods in CoreLib
+                        if (ecmaMethod.OwningType.Module != ecmaMethod.Context.SystemModule)
+                            ThrowHelper.ThrowBadImageFormatException();
+                    }
+                }
+
                 MethodIL methodIL = EcmaMethodIL.Create(ecmaMethod);
                 if (methodIL != null)
                     return methodIL;
@@ -354,6 +370,11 @@ public override MethodIL GetMethodIL(MethodDesc method)
                 return ArrayMethodILEmitter.EmitIL((ArrayMethod)method);
             }
             else
+            if (method is AsyncVariantImplMethod asyncVariantImpl)
+            {
+                return EcmaMethodIL.Create(asyncVariantImpl.MetadataDefinition);
+            }
+            else
             {
                 Debug.Assert(!(method is PInvokeTargetNativeMethod), "Who is asking for IL of PInvokeTargetNativeMethod?");
                 return null;

src/coreclr/tools/Common/TypeSystem/IL/Stubs/AsyncThunks.cs

@@ -0,0 +1,40 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Internal.TypeSystem;
+
+namespace Internal.IL.Stubs
+{
+    public static class AsyncThunkILEmitter
+    {
+        public static MethodIL EmitTaskReturningThunk(MethodDesc taskReturningMethod, MethodDesc asyncMethod)
+        {
+            TypeSystemContext context = taskReturningMethod.Context;
+
+            var emitter = new ILEmitter();
+            var codestream = emitter.NewCodeStream();
+
+            // TODO: match EmitTaskReturningThunk in CoreCLR VM
+
+            MethodSignature sig = asyncMethod.Signature;
+            int numParams = (sig.IsStatic || sig.IsExplicitThis) ? sig.Length : sig.Length + 1;
+            for (int i = 0; i < numParams; i++)
+                codestream.EmitLdArg(i);
+
+            codestream.Emit(ILOpcode.call, emitter.NewToken(asyncMethod));
+
+            if (sig.ReturnType.IsVoid)
+            {
+                codestream.Emit(ILOpcode.call, emitter.NewToken(context.SystemModule.GetKnownType("System.Threading.Tasks"u8, "Task"u8).GetKnownMethod("get_CompletedTask"u8, null)));
+            }
+            else
+            {
+                codestream.Emit(ILOpcode.call, emitter.NewToken(context.SystemModule.GetKnownType("System.Threading.Tasks"u8, "Task"u8).GetKnownMethod("FromResult"u8, null).MakeInstantiatedMethod(sig.ReturnType)));
+            }
+
+            codestream.Emit(ILOpcode.ret);
+
+            return emitter.Link(taskReturningMethod);
+        }
+    }
+}