Async main codegen

src/Compilers/CSharp/Portable/Binder/Binder_Await.cs

@@ -29,7 +29,7 @@ private BoundExpression BindAwait(BoundExpression expression, SyntaxNode node, D
             bool hasErrors =
                 ReportBadAwaitWithoutAsync(node, diagnostics) |
                 ReportBadAwaitContext(node, diagnostics) |
-                !GetAwaitableExpressionInfo(expression, out getAwaiter, out isCompleted, out getResult, node, diagnostics);
+                !GetAwaitableExpressionInfo(expression, out getAwaiter, out isCompleted, out getResult, out _, node, diagnostics);
 
             // Spec 7.7.7.2:
             // The expression await t is classified the same way as the expression (t).GetAwaiter().GetResult(). Thus,
@@ -209,17 +209,19 @@ private bool ReportBadAwaitContext(SyntaxNode node, DiagnosticBag diagnostics)
         /// Finds and validates the required members of an awaitable expression, as described in spec 7.7.7.1.
         /// </summary>
         /// <returns>True if the expression is awaitable; false otherwise.</returns>
-        private bool GetAwaitableExpressionInfo(
+        internal bool GetAwaitableExpressionInfo(
             BoundExpression expression,
             out MethodSymbol getAwaiter,
             out PropertySymbol isCompleted,
             out MethodSymbol getResult,
+            out BoundExpression getAwaiterGetResultCall,
             SyntaxNode node,
             DiagnosticBag diagnostics)
         {
             getAwaiter = null;
             isCompleted = null;
             getResult = null;
+            getAwaiterGetResultCall = null;
 
             if (!ValidateAwaitedExpression(expression, node, diagnostics))
             {
@@ -231,15 +233,16 @@ private bool GetAwaitableExpressionInfo(
                 return true;
             }
 
-            if (!GetGetAwaiterMethod(expression, node, diagnostics, out getAwaiter))
+            BoundExpression getAwaiterCall = null;
+            if (!GetGetAwaiterMethod(expression, node, diagnostics, out getAwaiter, out getAwaiterCall))
             {
                 return false;
             }
 
             TypeSymbol awaiterType = getAwaiter.ReturnType;
             return GetIsCompletedProperty(awaiterType, node, expression.Type, diagnostics, out isCompleted)
                 && AwaiterImplementsINotifyCompletion(awaiterType, node, diagnostics)
-                && GetGetResultMethod(awaiterType, node, expression.Type, diagnostics, out getResult);
+                && GetGetResultMethod(getAwaiterCall, node, expression.Type, diagnostics, out getResult, out getAwaiterGetResultCall);
         }
 
         /// <summary>
@@ -273,26 +276,29 @@ private static bool ValidateAwaitedExpression(BoundExpression expression, Syntax
         /// NOTE: this is an error in the spec.  An extension method of the form
         /// Awaiter&lt;T&gt; GetAwaiter&lt;T&gt;(this Task&lt;T&gt;) may be used.
         /// </remarks>
-        private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, DiagnosticBag diagnostics, out MethodSymbol getAwaiterMethod)
+        private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, DiagnosticBag diagnostics, out MethodSymbol getAwaiterMethod, out BoundExpression getAwaiterCall)
         {
             if (expression.Type.SpecialType == SpecialType.System_Void)
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArgVoidCall, node);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
-            var getAwaiterCall = MakeInvocationExpression(node, expression, WellKnownMemberNames.GetAwaiter, ImmutableArray<BoundExpression>.Empty, diagnostics);
+            getAwaiterCall = MakeInvocationExpression(node, expression, WellKnownMemberNames.GetAwaiter, ImmutableArray<BoundExpression>.Empty, diagnostics);
             if (getAwaiterCall.HasAnyErrors) // && !expression.HasAnyErrors?
             {
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
             if (getAwaiterCall.Kind != BoundKind.Call)
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
@@ -303,6 +309,7 @@ private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, Di
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
                 getAwaiterMethod = null;
+                getAwaiterCall = null;
                 return false;
             }
 
@@ -383,35 +390,39 @@ private bool AwaiterImplementsINotifyCompletion(TypeSymbol awaiterType, SyntaxNo
         /// Spec 7.7.7.1:
         /// An Awaiter A has an accessible instance method GetResult with no parameters and no type parameters.
         /// </remarks>
-        private bool GetGetResultMethod(TypeSymbol awaiterType, SyntaxNode node, TypeSymbol awaitedExpressionType, DiagnosticBag diagnostics, out MethodSymbol getResultMethod)
+        private bool GetGetResultMethod(BoundExpression awaiterExpression, SyntaxNode node, TypeSymbol awaitedExpressionType, DiagnosticBag diagnostics, out MethodSymbol getResultMethod, out BoundExpression getAwaiterGetResultCall)
         {
-            var receiver = new BoundLiteral(node, ConstantValue.Null, awaiterType);
-            var getResultCall = MakeInvocationExpression(node, receiver, WellKnownMemberNames.GetResult, ImmutableArray<BoundExpression>.Empty, diagnostics);
-            if (getResultCall.HasAnyErrors)
+            var awaiterType = awaiterExpression.Type;
+            getAwaiterGetResultCall = MakeInvocationExpression(node, awaiterExpression, WellKnownMemberNames.GetResult, ImmutableArray<BoundExpression>.Empty, diagnostics);
+            if (getAwaiterGetResultCall.HasAnyErrors)
             {
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
-            if (getResultCall.Kind != BoundKind.Call)
+            if (getAwaiterGetResultCall.Kind != BoundKind.Call)
             {
                 Error(diagnostics, ErrorCode.ERR_NoSuchMember, node, awaiterType, WellKnownMemberNames.GetResult);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
-            getResultMethod = ((BoundCall)getResultCall).Method;
+            getResultMethod = ((BoundCall)getAwaiterGetResultCall).Method;
             if (getResultMethod.IsExtensionMethod)
             {
                 Error(diagnostics, ErrorCode.ERR_NoSuchMember, node, awaiterType, WellKnownMemberNames.GetResult);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 
             if (HasOptionalOrVariableParameters(getResultMethod) || getResultMethod.IsConditional)
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaiterPattern, node, awaiterType, awaitedExpressionType);
                 getResultMethod = null;
+                getAwaiterGetResultCall = null;
                 return false;
             }
 

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

@@ -1457,7 +1457,7 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                 var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
                 foreach (var candidate in entryPointCandidates)
                 {
-                    if (!candidate.HasEntryPointSignature(this))
+                    if (!HasEntryPointSignature(candidate, warnings))
                     {
                         // a single error for partial methods
                         warnings.Add(ErrorCode.WRN_InvalidMainSig, candidate.Locations.First(), candidate);
@@ -1471,10 +1471,13 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                         continue;
                     }
 
+                    // PROTOTYPE(async-main): CheckFeatureAvailability should be called on non-async methods 
+                    // that return Task or Task<T>
                     if (candidate.IsAsync)
                     {
                         // PROTOTYPE(async-main): Get the diagnostic to point to a smaller syntax piece.
-                        CheckFeatureAvailability(candidate.DeclaringSyntaxReferences.Single().GetSyntax(), MessageID.IDS_FeatureAsyncMain, diagnostics);
+                        // PROTOTYPE(async-main): Switch diagnostics around if the type is not Task or Task<T>
+                        CheckFeatureAvailability(candidate.GetNonNullSyntaxNode(), MessageID.IDS_FeatureAsyncMain, diagnostics);
                     }
 
                     viableEntryPoints.Add(candidate);
@@ -1525,6 +1528,105 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
             }
         }
 
+        internal bool ReturnsAwaitableToVoidOrInt(MethodSymbol method, DiagnosticBag diagnostics)
+        {
+            // Common case optimization
+            if (method.ReturnType.SpecialType == SpecialType.System_Void || method.ReturnType.SpecialType == SpecialType.System_Int32)
+            {
+                return false;
+            }
+
+            if (!(method.ReturnType is NamedTypeSymbol namedType))
+            {
+                return false;
+            }
+
+            // Early bail so we only even check things that are System.Threading.Tasks.Task(<T>)
+            if (!(namedType.ConstructedFrom == GetWellKnownType(WellKnownType.System_Threading_Tasks_Task) ||
+                  namedType.ConstructedFrom == GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T)))
+            {
+                return false;
+            }
+
+
+            var syntax = method.ExtractReturnTypeSyntax();
+            var dumbInstance = new BoundLiteral(syntax, ConstantValue.Null, method.ReturnType);
+            // PROTOTYPE(async-main): We might need to adjust the containing member of the binder to be the Main method
+            var binder = GetBinder(syntax);
+            BoundExpression result;
+            var success = binder.GetAwaitableExpressionInfo(dumbInstance, out _, out _, out _, out result, syntax, diagnostics);
+
+            return success &&
+                (result.Type.SpecialType == SpecialType.System_Void || result.Type.SpecialType == SpecialType.System_Int32);
+        }
+
+        /// <summary>
+        /// Checks if the method has an entry point compatible signature, i.e.
+        /// - the return type is either void, int, <see cref="System.Threading.Tasks.Task" />,
+        /// or <see cref="System.Threading.Tasks.Task{T}" /> where T is an int.
+        /// - has either no parameter or a single parameter of type string[]
+        /// </summary>
+        private bool HasEntryPointSignature(MethodSymbol method, DiagnosticBag bag)
+        {
+            if (method.IsVararg)
+            {
+                return false;
+            }
+
+            TypeSymbol returnType = method.ReturnType;
+            bool returnsTaskOrTaskOfInt = false;
+            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void)
+            {
+                // Never look for ReturnsAwaitableToVoidOrInt on int32 or void
+                returnsTaskOrTaskOfInt = ReturnsAwaitableToVoidOrInt(method, bag);
+                if (!returnsTaskOrTaskOfInt)
+                {
+                    return false;
+                }
+            }
+
+            // Prior to 7.1, async methods were considered to "have the entrypoint signature".
+            // In order to keep back-compat, we need to let these through if compiling using a previous language version.
+            if (!returnsTaskOrTaskOfInt && method.IsAsync && this.LanguageVersion >= LanguageVersion.CSharp7_1)
+            {
+                return false;
+            }
+
+            if (method.RefKind != RefKind.None)
+            {
+                return false;
+            }
+
+            if (method.RefKind != RefKind.None)
+            {
+                return false;
+            }
+
+            if (method.Parameters.Length == 0)
+            {
+                return true;
+            }
+
+            if (method.Parameters.Length > 1)
+            {
+                return false;
+            }
+
+            if (!method.ParameterRefKinds.IsDefault)
+            {
+                return false;
+            }
+
+            var firstType = method.Parameters[0].Type;
+            if (firstType.TypeKind != TypeKind.Array)
+            {
+                return false;
+            }
+
+            var array = (ArrayTypeSymbol)firstType;
+            return array.IsSZArray && array.ElementType.SpecialType == SpecialType.System_String;
+        }
+
         internal override bool IsUnreferencedAssemblyIdentityDiagnosticCode(int code)
             => code == (int)ErrorCode.ERR_NoTypeDef;
 

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -184,6 +184,8 @@ public static void CompileMethodBodies(
             }
         }
 
+        // Returns the MethodSymbol for the assembly entrypoint.  If the user has a Task returning main,
+        // this function returns the synthesized Main MethodSymbol.
         private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuilt, bool hasDeclarationErrors, DiagnosticBag diagnostics, CancellationToken cancellationToken)
         {
             var entryPointAndDiagnostics = compilation.GetEntryPointAndDiagnostics(cancellationToken);
@@ -194,9 +196,26 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
 
             Debug.Assert(!entryPointAndDiagnostics.Diagnostics.IsDefault);
             diagnostics.AddRange(entryPointAndDiagnostics.Diagnostics);
-
             var entryPoint = entryPointAndDiagnostics.MethodSymbol;
-            var synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+
+            if ((object)entryPoint == null)
+            {
+                Debug.Assert(entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
+                return null;
+            }
+
+            // entryPoint can be a SynthesizedEntryPointSymbol if a script is being compiled.
+            SynthesizedEntryPointSymbol synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+            if ((object)synthesizedEntryPoint == null && compilation.ReturnsAwaitableToVoidOrInt(entryPoint, diagnostics))
+            {
+                synthesizedEntryPoint = new SynthesizedEntryPointSymbol.AsyncForwardEntryPoint(compilation, diagnostics, entryPoint.ContainingType, entryPoint);
+                entryPoint = synthesizedEntryPoint;
+                if ((object)moduleBeingBuilt != null)
+                {
+                    moduleBeingBuilt.AddSynthesizedDefinition(entryPoint.ContainingType, synthesizedEntryPoint);
+                }
+            }
+
             if (((object)synthesizedEntryPoint != null) &&
                 (moduleBeingBuilt != null) &&
                 !hasDeclarationErrors &&
@@ -221,7 +240,6 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody);
             }
 
-            Debug.Assert((object)entryPoint != null || entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
             return entryPoint;
         }