Rename AsyncMethodDesc to AsyncMethodVariant, add "AsyncVariant" flag to MethodWithToken and MethodWithGCInfo

src/coreclr/tools/Common/TypeSystem/Common/AsyncMethodThunk.cs

@@ -0,0 +1,103 @@
+// 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 System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Internal.TypeSystem;
+
+namespace Internal.TypeSystem
+{
+    /// <summary>
+    /// Represents the async-callable (CORINFO_CALLCONV_ASYNCCALL) variant of a Task/ValueTask returning method.
+    /// </summary>
+    public sealed class AsyncMethodThunk : MethodDelegator
+    {
+        private readonly AsyncMethodData _asyncMethodData;
+
+        public AsyncMethodThunk(MethodDesc wrappedMethod)
+            : base(wrappedMethod)
+        {
+            Debug.Assert(wrappedMethod.IsTaskReturning);
+            Debug.Assert(!wrappedMethod.IsAsync);
+            _asyncMethodData = new AsyncMethodData()
+            {
+                Kind = AsyncMethodKind.AsyncVariantThunk,
+                Signature = _wrappedMethod.Signature.CreateAsyncSignature()
+            };
+        }
+
+        public override AsyncMethodData AsyncMethodData
+        {
+            get
+            {
+                return _asyncMethodData;
+            }
+        }
+
+        public override MethodDesc GetCanonMethodTarget(CanonicalFormKind kind)
+        {
+            return _wrappedMethod.GetCanonMethodTarget(kind).GetAsyncOtherVariant();
+        }
+
+        public override MethodDesc GetMethodDefinition()
+        {
+            return _wrappedMethod.GetMethodDefinition();
+        }
+
+        public override MethodDesc GetTypicalMethodDefinition()
+        {
+            return _wrappedMethod.GetTypicalMethodDefinition();
+        }
+
+        public override MethodDesc GetAsyncOtherVariant()
+        {
+            return _wrappedMethod;
+        }
+
+        public override MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation)
+        {
+            MethodDesc real = _wrappedMethod.InstantiateSignature(typeInstantiation, methodInstantiation);
+            return real.GetAsyncOtherVariant();
+        }
+
+        public override MethodSignature Signature
+        {
+            get
+            {
+                return _asyncMethodData.Signature;
+            }
+        }
+
+        public override string DiagnosticName
+        {
+            get
+            {
+                return "Async thunk: " + _wrappedMethod.DiagnosticName;
+            }
+        }
+
+        protected internal override int ClassCode
+        {
+            get
+            {
+                return 0x554d08b9;
+            }
+        }
+
+        protected internal override int CompareToImpl(MethodDesc other, TypeSystemComparer comparer)
+        {
+            if (other is AsyncMethodThunk otherAsync)
+            {
+                return comparer.Compare(_wrappedMethod, otherAsync._wrappedMethod);
+            }
+            return -1;
+        }
+
+        public override string ToString()
+        {
+            return "Async thunk: " + _wrappedMethod.ToString();
+        }
+    }
+}

src/coreclr/tools/Common/TypeSystem/Common/InstantiatedMethod.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Diagnostics;
+using System.Threading;
 using Internal.NativeFormat;
 
 namespace Internal.TypeSystem
@@ -13,6 +14,8 @@
         private Instantiation _instantiation;
 
         private MethodSignature _signature;
+        private AsyncMethodData _asyncMethodData;
+        private MethodDesc _asyncOtherVariant;
 
         internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation)
         {
@@ -58,26 +61,73 @@
             return type.InstantiateSignature(default(Instantiation), _instantiation);
         }
 
+        private void InitializeSignature()
+        {
+            var template = _methodDef.Signature;
+            _signature = InstantiateSignature(template);
+        }
+
+        private MethodSignature InstantiateSignature(MethodSignature template)
+        {
+            var builder = new MethodSignatureBuilder(template);
+            builder.ReturnType = Instantiate(template.ReturnType);
+            for (int i = 0; i < template.Length; i++)
+                builder[i] = Instantiate(template[i]);
+            return builder.ToSignature();
+        }
+
         public override MethodSignature Signature
         {
             get
             {
                 if (_signature == null)
-                {
-                    MethodSignature template = _methodDef.Signature;
-                    MethodSignatureBuilder builder = new MethodSignatureBuilder(template);
+                    InitializeSignature();
+
+                return _signature;
+            }
+        }
 
-                    builder.ReturnType = Instantiate(template.ReturnType);
-                    for (int i = 0; i < template.Length; i++)
-                        builder[i] = Instantiate(template[i]);
+        public override AsyncMethodData AsyncMethodData
+        {
+            get
+            {
+                if (!_asyncMethodData.Equals(default(AsyncMethodData)))
+                    return _asyncMethodData;
 
-                    _signature = builder.ToSignature();
+                if (Signature.ReturnsTaskOrValueTask())
+                {
+                    if (IsAsync)
+                    {
+                        // If the method is already async, the template signature should already have been updated to reflect the AsyncCallConv
+                        Debug.Assert(!Signature.ReturnsTaskOrValueTask() && Signature.IsAsyncCallConv);
+                        _asyncMethodData = new AsyncMethodData() { Kind = AsyncMethodKind.AsyncVariantImpl, Signature = Signature };
+                    }
+                    else
+                    {
+                        _asyncMethodData = new AsyncMethodData() { Kind = AsyncMethodKind.TaskReturning, Signature = Signature };
+                    }
+                }
+                else
+                {
+                    _asyncMethodData = new AsyncMethodData() { Kind = AsyncMethodKind.NotAsync, Signature = Signature };
                 }
 
-                return _signature;
+                return _asyncMethodData;
             }
         }
 
+        public override MethodDesc GetAsyncOtherVariant()
+        {
+            if (_asyncOtherVariant is null)
+            {
+                MethodDesc otherVariant = IsAsync ?
+                    new TaskReturningAsyncThunk(this, InstantiateSignature(_methodDef.GetAsyncOtherVariant().Signature))
+                    : new AsyncMethodThunk(this);
+                Interlocked.CompareExchange(ref _asyncOtherVariant, otherVariant, null);
+            }
+            return _asyncOtherVariant;
+        }
+
         public override Instantiation Instantiation
         {
             get
@@ -134,7 +184,6 @@
             }
         }
 
-
         public override bool HasCustomAttribute(string attributeNamespace, string attributeName)
         {
             return _methodDef.HasCustomAttribute(attributeNamespace, attributeName);

src/coreclr/tools/Common/TypeSystem/Common/MethodDelegator.cs

@@ -53,5 +53,7 @@ public override bool HasCustomAttribute(string attributeNamespace, string attrib
 
         // For this method, delegating to the wrapped MethodDesc would likely be the wrong thing.
         public abstract override MethodDesc InstantiateSignature(Instantiation typeInstantiation, Instantiation methodInstantiation);
+
+        public abstract override AsyncMethodData AsyncMethodData { get; }
     }
 }