Async main codegen

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

@@ -2059,28 +2059,31 @@ private AssemblySymbol GetForwardedToAssembly(string fullName, int arity, Diagno
             return null;
         }
 
-        internal static void CheckFeatureAvailability(SyntaxNode syntax, MessageID feature, DiagnosticBag diagnostics, Location locationOpt = null)
+        internal static bool CheckFeatureAvailability(SyntaxNode syntax, MessageID feature, DiagnosticBag diagnostics, Location locationOpt = null)
         {
             var options = (CSharpParseOptions)syntax.SyntaxTree.Options;
             if (options.IsFeatureEnabled(feature))
             {
-                return;
+                return true;
             }
 
             var location = locationOpt ?? syntax.GetLocation();
             string requiredFeature = feature.RequiredFeature();
             if (requiredFeature != null)
             {
                 diagnostics.Add(ErrorCode.ERR_FeatureIsExperimental, location, feature.Localize(), requiredFeature);
-                return;
+                return false;
             }
 
             LanguageVersion availableVersion = options.LanguageVersion;
             LanguageVersion requiredVersion = feature.RequiredVersion();
             if (requiredVersion > availableVersion)
             {
                 diagnostics.Add(availableVersion.GetErrorCode(), location, feature.Localize(), new CSharpRequiredLanguageVersion(requiredVersion));
+                return false;
             }
+
+            return true;
         }
     }
 }

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

@@ -1454,7 +1454,9 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                 }
 
                 DiagnosticBag warnings = DiagnosticBag.GetInstance();
+                DiagnosticBag possibleAsyncMainDiagnostics = DiagnosticBag.GetInstance();
                 var viableEntryPoints = ArrayBuilder<MethodSymbol>.GetInstance();
+                bool asyncOk = true;
                 foreach (var candidate in entryPointCandidates)
                 {
                     if (!candidate.HasEntryPointSignature(this))
@@ -1474,7 +1476,7 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                     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);
+                        asyncOk &= CheckFeatureAvailability(candidate.DeclaringSyntaxReferences.Single().GetSyntax(), MessageID.IDS_FeatureAsyncMain, possibleAsyncMainDiagnostics);
                     }
 
                     viableEntryPoints.Add(candidate);
@@ -1488,7 +1490,11 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                 warnings.Free();
 
                 MethodSymbol entryPoint = null;
-                if (viableEntryPoints.Count == 0)
+
+                int nonAsyncCount = viableEntryPoints.Count(c => !c.IsAsync);
+                int asyncCount = viableEntryPoints.Count - nonAsyncCount;
+
+                if (nonAsyncCount == 0 && asyncCount == 0)
                 {
                     if ((object)mainType == null)
                     {
@@ -1499,22 +1505,31 @@ private MethodSymbol FindEntryPoint(CancellationToken cancellationToken, out Imm
                         diagnostics.Add(ErrorCode.ERR_NoMainInClass, mainType.Locations.First(), mainType);
                     }
                 }
-                else if (viableEntryPoints.Count > 1)
+                else if (nonAsyncCount == 1)
+                {
+                    entryPoint = viableEntryPoints.Single(c => !c.IsAsync);
+                }
+                else if (nonAsyncCount == 0 && asyncCount == 1)
+                {
+                    diagnostics.AddRange(possibleAsyncMainDiagnostics);
+                    entryPoint = viableEntryPoints.Single();
+                }
+                else if (nonAsyncCount == 0 && !asyncOk)
+                {
+                    diagnostics.AddRange(possibleAsyncMainDiagnostics);
+                }
+                else
                 {
                     viableEntryPoints.Sort(LexicalOrderSymbolComparer.Instance);
                     var info = new CSDiagnosticInfo(
                          ErrorCode.ERR_MultipleEntryPoints,
                          args: Array.Empty<object>(),
                          symbols: viableEntryPoints.OfType<Symbol>().AsImmutable(),
                          additionalLocations: viableEntryPoints.Select(m => m.Locations.First()).OfType<Location>().AsImmutable());
-
                     diagnostics.Add(new CSDiagnostic(info, viableEntryPoints.First().Locations.First()));
                 }
-                else
-                {
-                    entryPoint = viableEntryPoints[0];
-                }
 
+                possibleAsyncMainDiagnostics.Free();
                 viableEntryPoints.Free();
                 return entryPoint;
             }

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 && entryPoint.HasAsyncMainReturnType(compilation) && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
+            {
+                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;
         }
 

src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs

@@ -595,6 +595,29 @@ internal bool IsEntryPointCandidate
             get { return IsStatic && Name == WellKnownMemberNames.EntryPointMethodName; }
         }
 
+        internal bool HasAsyncMainReturnType(CSharpCompilation compilation)
+        {
+            var namedType = ReturnType as NamedTypeSymbol;
+            if ((object)namedType == null)
+            {
+                return false;
+            }
+            else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task))
+            {
+                // Change this to `namedType.IsNonGenericTaskType` if you want to support "task-like" objects.
+                return true;
+            }
+            else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T))
+            {
+                // Change this to `namedType.IsGenericTaskType` if you want to support "task-like" objects.
+                return namedType.TypeArguments[0].SpecialType == SpecialType.System_Int32;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
         /// <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" />,
@@ -603,37 +626,13 @@ internal bool IsEntryPointCandidate
         /// </summary>
         internal bool HasEntryPointSignature(CSharpCompilation compilation)
         {
-
-            bool IsAsyncMainReturnType(TypeSymbol type)
-            {
-                var namedType = type as NamedTypeSymbol;
-                if (namedType == null)
-                {
-                    return false;
-                }
-                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task))
-                {
-                    // Change this to `namedType.IsNonGenericTaskType` if you want to support "task-like" objects.
-                    return true;
-                }
-                else if (namedType.ConstructedFrom == compilation.GetWellKnownType(WellKnownType.System_Threading_Tasks_Task_T))
-                {
-                    // Change this to `namedType.IsGenericTaskType` if you want to support "task-like" objects.
-                    return namedType.TypeArguments[0].SpecialType == SpecialType.System_Int32;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-
             if (IsVararg)
             {
                 return false;
             }
 
             TypeSymbol returnType = ReturnType;
-            bool isAsyncMainReturnType = IsAsyncMainReturnType(returnType);
+            bool isAsyncMainReturnType = HasAsyncMainReturnType(compilation);
             if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void && !isAsyncMainReturnType)
             {
                 return false;

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedEntryPointSymbol.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -301,12 +302,17 @@ private static void ReportUseSiteDiagnostics(Symbol symbol, DiagnosticBag diagno
             }
         }
 
-        private static MethodSymbol GetRequiredMethod(TypeSymbol type, string methodName, DiagnosticBag diagnostics)
+        private static MethodSymbol GetRequiredMethod(TypeSymbol type, string methodName, DiagnosticBag diagnostics, Location location = null)
         {
+            if ((object)location == null)
+            {
+                location = NoLocation.Singleton;
+            }
+
             var method = type.GetMembers(methodName).SingleOrDefault() as MethodSymbol;
             if ((object)method == null)
             {
-                diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, NoLocation.Singleton, type, methodName);
+                diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, location, type, methodName);
             }
             return method;
         }
@@ -329,6 +335,123 @@ private static BoundCall CreateParameterlessCall(CSharpSyntaxNode syntax, BoundE
             { WasCompilerGenerated = true };
         }
 
+        // A synthesized entrypoint that forwards all calls to an async Main Method
+        internal sealed class AsyncForwardEntryPoint : SynthesizedEntryPointSymbol
+        {
+            // The user-defined asynchronous main method.
+            private readonly MethodSymbol _userMain;
+
+            private readonly MethodSymbol _getAwaiterMethod;
+            private readonly MethodSymbol _getResultMethod;
+
+            private readonly ImmutableArray<ParameterSymbol> _parameters;
+
+            // Task -> Void
+            // Task<_> -> Int32
+            private static TypeSymbol TranslateReturnType(CSharpCompilation compilation, TypeSymbol returnType)
+            {
+                return returnType.IsGenericTaskType(compilation)
+                    ? compilation.GetSpecialType(SpecialType.System_Int32)
+                    : compilation.GetSpecialType(SpecialType.System_Void);
+            }
+
+            internal AsyncForwardEntryPoint(CSharpCompilation compilation, DiagnosticBag diagnosticBag, NamedTypeSymbol containingType, MethodSymbol userMain) :
+                base(containingType, TranslateReturnType(compilation, userMain.ReturnType))
+            {
+                // There should be no way for a userMain to be passed in unless it already passed the 
+                // parameter checks for determining entrypoint validity.
+                Debug.Assert(userMain.ParameterCount == 0 || userMain.ParameterCount == 1);
+
+                _userMain = userMain;
+                _parameters = SynthesizedParameterSymbol.DeriveParameters(userMain, this);
+
+                var userMainLocation = userMain.DeclaringSyntaxReferences.SingleOrDefault()?.GetLocation();
+
+                _getAwaiterMethod = GetRequiredMethod(_userMain.ReturnType, WellKnownMemberNames.GetAwaiter, diagnosticBag, userMainLocation);
+                if ((object)_getAwaiterMethod != null)
+                {
+                    _getResultMethod = GetRequiredMethod(_getAwaiterMethod.ReturnType, WellKnownMemberNames.GetResult, diagnosticBag, userMainLocation);
+                }
+            }
+
+            public override string Name => MainName;
+
+            public override ImmutableArray<ParameterSymbol> Parameters => _parameters;
+
+            internal override BoundBlock CreateBody()
+            {
+                var syntax = this.GetSyntax();
+
+                var arguments = Parameters.SelectAsArray(p => (BoundExpression)new BoundParameter(syntax, p, p.Type));
+
+                // Main(args) or Main()
+                BoundCall userMainInvocation = new BoundCall(
+                        syntax: this.GetSyntax(),
+                        receiverOpt: null,
+                        method: _userMain,
+                        arguments: arguments,
+                        argumentNamesOpt: default(ImmutableArray<string>),
+                        argumentRefKindsOpt: default(ImmutableArray<RefKind>),
+                        isDelegateCall: false,
+                        expanded: false,
+                        invokedAsExtensionMethod: false,
+                        argsToParamsOpt: default(ImmutableArray<int>),
+                        resultKind: LookupResultKind.Viable,
+                        type: _userMain.ReturnType)
+                { WasCompilerGenerated = true };
+
+                // GetAwaiter().GetResult()
+                BoundCall getAwaiterGetResult =
+                    CreateParameterlessCall(
+                            syntax: syntax,
+                            method: _getResultMethod,
+                            receiver: CreateParameterlessCall(
+                                syntax: syntax,
+                                method: _getAwaiterMethod,
+                                receiver: userMainInvocation
+                            )
+                    );
+
+                if (ReturnsVoid)
+                {
+                    return new BoundBlock(
+                        syntax: syntax,
+                        locals: ImmutableArray<LocalSymbol>.Empty,
+                        statements: ImmutableArray.Create<BoundStatement>(
+                            new BoundExpressionStatement(
+                                syntax: syntax,
+                                expression: getAwaiterGetResult
+                            )
+                            { WasCompilerGenerated = true },
+                            new BoundReturnStatement(
+                                syntax: syntax,
+                                refKind: RefKind.None,
+                                expressionOpt: null
+                            )
+                            { WasCompilerGenerated = true }
+                        )
+                    )
+                    { WasCompilerGenerated = true };
+
+                }
+                else
+                {
+                    return new BoundBlock(
+                        syntax: syntax,
+                        locals: ImmutableArray<LocalSymbol>.Empty,
+                        statements: ImmutableArray.Create<BoundStatement>(
+                            new BoundReturnStatement(
+                                syntax: syntax,
+                                refKind: RefKind.None,
+                                expressionOpt: getAwaiterGetResult
+                            )
+                        )
+                    )
+                    { WasCompilerGenerated = true };
+                }
+            }
+        }
+
         private sealed class ScriptEntryPoint : SynthesizedEntryPointSymbol
         {
             private readonly MethodSymbol _getAwaiterMethod;
@@ -344,15 +467,9 @@ internal ScriptEntryPoint(NamedTypeSymbol containingType, TypeSymbol returnType,
                 _getResultMethod = getResultMethod;
             }
 
-            public override string Name
-            {
-                get { return MainName; }
-            }
+            public override string Name => MainName;
 
-            public override ImmutableArray<ParameterSymbol> Parameters
-            {
-                get { return ImmutableArray<ParameterSymbol>.Empty; }
-            }
+            public override ImmutableArray<ParameterSymbol> Parameters => ImmutableArray<ParameterSymbol>.Empty;
 
             // private static void <Main>()
             // {