Add RuntimeAsyncMethodGenerationAttribute (#77543)

Adds control for whether to use runtime async. The flowchart is as follows:

1. The flag `System.Runtime.CompilerServices.RuntimeFeature.Async` must be present.
2. Assuming that flag is present, we look for the presence of `System.Runtime.CompilerServices.RuntimeAsyncMethodGenerationAttribute` on the method. If that attribute is present, we use the preference expressed in the attribute. The preference does not carry to nested contexts, such as local functions or lambdas.
3. If the attribute is not present, we look for `features:runtime-async=on` on the command line. If that is present, then the feature is on by default. Otherwise, the feature is off.

Author: 333fred

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -316,9 +316,7 @@ internal bool IsNullableAnalysisEnabledAlways
         /// Returns true if this method should be processed with runtime async handling instead
         /// of compiler async state machine generation.
         /// </summary>
-#pragma warning disable IDE0060 // Remove unused parameter
         internal bool IsRuntimeAsyncEnabledIn(MethodSymbol method)
-#pragma warning restore IDE0060 // Remove unused parameter
         {
             // PROTOTYPE: EE tests fail this assert, handle and test
             //Debug.Assert(ReferenceEquals(method.ContainingAssembly, Assembly));
@@ -327,8 +325,12 @@ internal bool IsRuntimeAsyncEnabledIn(MethodSymbol method)
                 return false;
             }
 
-            // PROTOTYPE: Check for attributes that turn on/off the feature member-by-member
-            return true;
+            return method switch
+            {
+                SourceMethodSymbol { IsRuntimeAsyncEnabledInMethod: ThreeState.True } => true,
+                SourceMethodSymbol { IsRuntimeAsyncEnabledInMethod: ThreeState.False } => false,
+                _ => Feature("runtime-async") == "on"
+            };
         }
 
         /// <summary>

src/Compilers/CSharp/Portable/Symbols/Attributes/WellKnownAttributeData/MethodWellKnownAttributeData.cs

@@ -149,5 +149,21 @@ public UnmanagedCallersOnlyAttributeData? UnmanagedCallersOnlyAttributeData
                 SetDataStored();
             }
         }
+
+        private ThreeState _runtimeAsyncMethodGenerationSetting;
+        public ThreeState RuntimeAsyncMethodGenerationSetting
+        {
+            get
+            {
+                VerifySealed(expected: true);
+                return _runtimeAsyncMethodGenerationSetting;
+            }
+            set
+            {
+                VerifySealed(expected: false);
+                _runtimeAsyncMethodGenerationSetting = value;
+                SetDataStored();
+            }
+        }
     }
 }

src/Compilers/CSharp/Portable/Symbols/Source/SourceMethodSymbolWithAttributes.cs

@@ -651,6 +651,14 @@ private void DecodeWellKnownAttributeAppliedToMethod(ref DecodeWellKnownAttribut
                         arguments.AttributeSyntaxOpt);
                 }
             }
+            else if (attribute.IsTargetAttribute(AttributeDescription.RuntimeAsyncMethodGenerationAttribute))
+            {
+                // PROTOTYPE: Validate langversion? Validate previewness of the runtime feature flag?
+                arguments.GetOrCreateData<MethodWellKnownAttributeData>().RuntimeAsyncMethodGenerationSetting =
+                    attribute.CommonConstructorArguments[0].DecodeValue<bool>(SpecialType.System_Boolean)
+                        ? ThreeState.True
+                        : ThreeState.False;
+            }
             else
             {
                 var compilation = this.DeclaringCompilation;
@@ -661,6 +669,9 @@ private void DecodeWellKnownAttributeAppliedToMethod(ref DecodeWellKnownAttribut
             }
         }
 
+        internal ThreeState IsRuntimeAsyncEnabledInMethod
+            => GetDecodedWellKnownAttributeData()?.RuntimeAsyncMethodGenerationSetting ?? ThreeState.Unknown;
+
         internal override ImmutableArray<string> NotNullMembers =>
             GetDecodedWellKnownAttributeData()?.NotNullMembers ?? ImmutableArray<string>.Empty;