Enable compilation of async thunks in composite mode

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

@@ -171,5 +171,11 @@ public static MethodDesc GetTargetOfAsyncVariant(this MethodDesc method)
             Debug.Assert(method.IsAsyncVariant());
             return ((CompilerTypeSystemContext)method.Context).GetTargetOfAsyncVariantMethod(method);
         }
+
+        public static MethodDesc GetTargetOfReturnDroppingAsyncThunk(this MethodDesc method)
+        {
+            Debug.Assert(method.IsReturnDroppingAsyncThunk());
+            return ((CompilerTypeSystemContext)method.Context).GetTargetOfReturnDroppingThunk(method);
+        }
     }
 }

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

@@ -207,6 +207,26 @@ public MethodDesc GetAsyncVariantMethod(MethodDesc taskReturningMethod)
             return result;
         }
 
+        public MethodDesc GetTargetOfReturnDroppingThunk(MethodDesc returnDroppingThunk)
+        {
+            Debug.Assert(returnDroppingThunk.IsReturnDroppingAsyncThunk());
+            var returnDroppingThunkDefinition = (ReturnDroppingAsyncThunk)returnDroppingThunk.GetTypicalMethodDefinition();
+            MethodDesc result = returnDroppingThunkDefinition.AsyncVariantTarget;
+
+            // If there are generics involved, we need to specialize
+            if (returnDroppingThunk != returnDroppingThunkDefinition)
+            {
+                TypeDesc owningType = returnDroppingThunk.OwningType;
+                if (owningType != returnDroppingThunkDefinition.OwningType)
+                    result = GetMethodForInstantiatedType(result, (InstantiatedType)owningType);
+
+                if (returnDroppingThunk.HasInstantiation && !returnDroppingThunk.IsMethodDefinition)
+                    result = GetInstantiatedMethod(result, returnDroppingThunk.Instantiation);
+            }
+
+            return result;
+        }
+
         private sealed class AsyncVariantHashtable : LockFreeReaderHashtable<EcmaMethod, AsyncMethodVariant>
         {
             protected override int GetKeyHashCode(EcmaMethod key) => key.GetHashCode();

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

@@ -1872,6 +1872,7 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
             else
             {
                 recordToken = (_compilation.CompilationModuleGroup.VersionsWithType(owningType) || _compilation.CompilationModuleGroup.CrossModuleInlineableType(owningType)) && owningType is EcmaType;
+                recordToken &= methodIL.GetMethodILScopeDefinition() is IMethodTokensAreUseableInCompilation || methodIL.GetMethodILScopeDefinition() is IEcmaMethodIL;
             }
 #endif
 
@@ -1884,7 +1885,8 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
 #if READYTORUN
                 if (recordToken)
                 {
-                    ModuleToken methodModuleToken = HandleToModuleToken(ref pResolvedToken);
+                    ModuleToken methodModuleToken = HandleToModuleToken(ref pResolvedToken, out bool strippedInstantiation);
+                    Debug.Assert(!strippedInstantiation);
                     var resolver = _compilation.NodeFactory.Resolver;
                     resolver.AddModuleTokenForMethod(method, methodModuleToken);
                     ValidateSafetyOfUsingTypeEquivalenceInSignature(method.Signature);
@@ -1951,7 +1953,8 @@ private void resolveToken(ref CORINFO_RESOLVED_TOKEN pResolvedToken)
 #if READYTORUN
                 if (recordToken)
                 {
-                    _compilation.NodeFactory.Resolver.AddModuleTokenForType(type, HandleToModuleToken(ref pResolvedToken));
+                    _compilation.NodeFactory.Resolver.AddModuleTokenForType(type, HandleToModuleToken(ref pResolvedToken, out bool strippedInstantiation));
+                    Debug.Assert(!strippedInstantiation);
                 }
 #endif
 

src/coreclr/tools/Common/TypeSystem/MetadataEmitter/TypeSystemMetadataEmitter.cs

@@ -35,6 +35,7 @@ internal class TypeSystemMetadataEmitter
             _metadataBuilder = new MetadataBuilder();
             _ilBuilder = new BlobBuilder();
             _methodBodyStream = new MethodBodyStreamEncoder(_ilBuilder);
+            _ = _metadataBuilder.GetOrAddString(string.Empty);
             StringHandle assemblyNameHandle = _metadataBuilder.GetOrAddString(assemblyName.Name);
             if (assemblyName.CultureName != null)
                 throw new ArgumentException("assemblyName");

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/CrossModuleInlining/AsyncInlineCallers.cs

@@ -0,0 +1,44 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+public static class AsyncInlineCallers
+{
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task CallReturnTaskNoAwait()
+    {
+        await AsyncInlineCandidatesLib.ReturnTaskNoAwait();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task<int> CallReturnTaskPrimitiveNoAwait()
+    {
+        return await AsyncInlineCandidatesLib.ReturnTaskPrimitiveNoAwait();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task<string> CallReturnTaskClassNoAwait()
+    {
+        return await AsyncInlineCandidatesLib.ReturnTaskClassNoAwait();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task CallReturnTaskWithAwait()
+    {
+        await AsyncInlineCandidatesLib.ReturnTaskWithAwait();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task<int> CallReturnTaskPrimitiveWithAwait()
+    {
+        return await AsyncInlineCandidatesLib.ReturnTaskPrimitiveWithAwait();
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static async Task<string> CallReturnTaskClassWithAwait()
+    {
+        return await AsyncInlineCandidatesLib.ReturnTaskClassWithAwait();
+    }
+}

src/coreclr/tools/aot/ILCompiler.ReadyToRun.Tests/TestCases/CrossModuleInlining/Dependencies/AsyncInlineCandidatesLib.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 System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
+public static class AsyncInlineCandidatesLib
+{
+    // --- Awaitless variants: should be inlinable ---
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task ReturnTaskNoAwait()
+    {
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task<int> ReturnTaskPrimitiveNoAwait() => 42;
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task<string> ReturnTaskClassNoAwait() => "no_await";
+
+    // --- Variants containing an actual await: cannot be inlined by the JIT ---
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task ReturnTaskWithAwait()
+    {
+        await Task.Yield();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task<int> ReturnTaskPrimitiveWithAwait()
+    {
+        await Task.Yield();
+        return 42;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static async Task<string> ReturnTaskClassWithAwait()
+    {
+        await Task.Yield();
+        return "with_await";
+    }
+}