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/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.ReturnsTaskOrTaskOfInt(compilation))
+            {
+                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 ReturnsTaskOrTaskOfInt(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,45 +626,21 @@ 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);
-            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void && !isAsyncMainReturnType)
+            bool returnsTaskOrTaskOfInt = ReturnsTaskOrTaskOfInt(compilation);
+            if (returnType.SpecialType != SpecialType.System_Int32 && returnType.SpecialType != SpecialType.System_Void && !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 (!isAsyncMainReturnType && IsAsync && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
+            if (!returnsTaskOrTaskOfInt && IsAsync && compilation.LanguageVersion >= LanguageVersion.CSharp7_1)
             {
                 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,122 @@ 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: syntax,
+                        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 +466,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>()
             // {

src/Compilers/CSharp/Test/Emit/CSharpCompilerEmitTest.csproj

@@ -67,6 +67,7 @@
     <Compile Include="Attributes\AttributeTests_Synthesized.cs" />
     <Compile Include="Attributes\AttributeTests_Tuples.cs" />
     <Compile Include="Attributes\AttributeTests_WellKnownAttributes.cs" />
+    <Compile Include="CodeGen\CodeGenAsyncMainTests.cs" />
     <Compile Include="CodeGen\CodeGenCapturing.cs" />
     <Compile Include="Emit\BinaryCompatibility.cs" />
     <Compile Include="Emit\DesktopStrongNameProviderTests.cs" />
@@ -190,4 +191,4 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="..\..\..\..\..\build\Targets\Imports.targets" />
-</Project>
+</Project>