Async main codegen

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

@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Emit;
 using Roslyn.Utilities;
+using static Microsoft.CodeAnalysis.CSharp.Symbols.SynthesizedEntryPointSymbol;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -184,6 +185,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);
@@ -196,7 +199,23 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
             diagnostics.AddRange(entryPointAndDiagnostics.Diagnostics);
 
             var entryPoint = entryPointAndDiagnostics.MethodSymbol;
-            var synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+
+            if (entryPoint == null)
+            {
+                Debug.Assert(entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
+                return null;
+            }
+
+            bool addedDefinition = false;
+            SynthesizedEntryPointSymbol synthesizedEntryPoint = entryPoint as SynthesizedEntryPointSymbol;
+
+            if ((object)synthesizedEntryPoint == null && entryPoint.HasAsyncMainReturnType(compilation) && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
+            {
+                synthesizedEntryPoint = new AsyncForwardEntryPoint(compilation, diagnostics, entryPoint.ContainingType, entryPoint);
+                entryPoint = synthesizedEntryPoint;
+                addedDefinition = true;
+            }
+
             if (((object)synthesizedEntryPoint != null) &&
                 (moduleBeingBuilt != null) &&
                 !hasDeclarationErrors &&
@@ -221,7 +240,11 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody);
             }
 
-            Debug.Assert((object)entryPoint != null || entryPointAndDiagnostics.Diagnostics.HasAnyErrors() || !compilation.Options.Errors.IsDefaultOrEmpty);
+            if (addedDefinition && moduleBeingBuilt != null)
+            {
+                moduleBeingBuilt.AddSynthesizedDefinition(entryPoint.ContainingType, synthesizedEntryPoint);
+            }
+
             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 (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" />,
@@ -604,36 +627,14 @@ internal bool IsEntryPointCandidate
         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;
@@ -329,6 +330,157 @@ 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 asyncrhonous main method.
+            private readonly MethodSymbol _userMain;
+            private DiagnosticBag _diagnosticBag;
+
+            private readonly ReturnKind _returnKind;
+            private readonly ParamKind _paramKind;
+
+            private readonly ImmutableArray<ParameterSymbol> _parameters;
+
+            // Which "kind" of Main is this: `void Main` or `int Main`?
+            // This is determined by looking at the return type of the user-provided Main
+            private enum ReturnKind
+            {
+                VoidReturning,
+                IntReturning,
+            }
+            // Does this main method need to forward arguments to the user-provided Main?
+            private enum ParamKind
+            {
+                NoArgs,
+                StringArrayArgs,
+            }
+
+            // 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);
+            }
+
+            // Task -> ReturnKind.VoidReturning
+            // Task<_> -> ReturnKind.IntReturning
+            private static ReturnKind GetReturnKind(CSharpCompilation compilation, TypeSymbol returnType)
+            {
+                return returnType.IsGenericTaskType(compilation) ? ReturnKind.IntReturning : ReturnKind.VoidReturning;
+            }
+
+            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;
+                _diagnosticBag = diagnosticBag;
+                _paramKind = userMain.ParameterCount == 0 ? ParamKind.NoArgs : ParamKind.StringArrayArgs;
+                _returnKind = GetReturnKind(compilation, userMain.ReturnType);
+
+                switch (_paramKind)
+                {
+                    case ParamKind.StringArrayArgs:
+                        var stringType = compilation.GetSpecialType(SpecialType.System_String);
+                        var stringArrayType = ArrayTypeSymbol.CreateCSharpArray(compilation.Assembly, stringType);
+                        _parameters = ImmutableArray.Create(
+                            SynthesizedParameterSymbol.Create(this, stringArrayType, 0, RefKind.None, userMain.Parameters[0].Name));
+                        break;
+                    default:
+                        _parameters = ImmutableArray<ParameterSymbol>.Empty;
+                        break;
+                }
+            }
+
+            public override string Name => MainName;
+
+            public override ImmutableArray<ParameterSymbol> Parameters => _parameters;
+
+            internal override BoundBlock CreateBody()
+            {
+                var syntax = this.GetSyntax();
+
+                var arguments = Parameters.SelectAsArray(p => new BoundParameter(syntax, p, p.Type) as BoundExpression);
+
+                // 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 };
+
+                // PROTOTYPE(async-main): Errors should likely be reported here instead of bailing.
+                var getAwaiterMethod = GetRequiredMethod(_userMain.ReturnType, WellKnownMemberNames.GetAwaiter, _diagnosticBag);
+                Debug.Assert(getAwaiterMethod != null);
+
+                var getResultMethod = GetRequiredMethod(getAwaiterMethod.ReturnType, WellKnownMemberNames.GetResult, _diagnosticBag);
+                Debug.Assert(getResultMethod != null);
+
+                // GetAwaiter().GetResult()
+                BoundCall getAwaiterGetResult =
+                    CreateParameterlessCall(
+                            syntax: syntax,
+                            method: getResultMethod,
+                            receiver: CreateParameterlessCall(
+                                syntax: syntax,
+                                method: getAwaiterMethod,
+                                receiver: userMainInvocation
+                            )
+                    );
+
+                BoundStatement statement = null;
+                switch (_returnKind)
+                {
+                    case ReturnKind.IntReturning:
+                        // return (GetAwaiter().GetResult())
+                        statement = new BoundReturnStatement(
+                            syntax: syntax,
+                            refKind: RefKind.None,
+                            expressionOpt: getAwaiterGetResult
+                        );
+                        break;
+                    case ReturnKind.VoidReturning:
+                        // { GetAwaiter().GetResult(); return; }
+                        statement = new BoundBlock(
+                            syntax: syntax,
+                            locals: ImmutableArray<LocalSymbol>.Empty,
+                            statements: ImmutableArray.Create<BoundStatement>(
+                                new BoundExpressionStatement(
+                                    syntax: syntax,
+                                    expression: getAwaiterGetResult
+                                ),
+                                new BoundReturnStatement(
+                                    syntax: syntax,
+                                    refKind: RefKind.None,
+                                    expressionOpt: null
+                                )
+                            )
+                        );
+                        break;
+                };
+
+                return new BoundBlock(
+                    syntax: syntax,
+                    locals: ImmutableArray<LocalSymbol>.Empty,
+                    statements: ImmutableArray.Create<BoundStatement>(statement));
+            }
+        }
+
         private sealed class ScriptEntryPoint : SynthesizedEntryPointSymbol
         {
             private readonly MethodSymbol _getAwaiterMethod;
@@ -344,15 +496,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>()
             // {