Allow overriding the AsyncMethodBuilder on methods

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

@@ -8597,8 +8597,7 @@ private bool ContainingMethodOrLambdaRequiresValue()
             return
                 (object)containingMethod == null ||
                     !containingMethod.ReturnsVoid &&
-                    !containingMethod.IsAsyncReturningTask(this.Compilation) &&
-                    !containingMethod.IsAsyncReturningTaskViaOverride(out _);
+                    !containingMethod.IsAsyncReturningTask(this.Compilation);
         }
 
         private BoundConditionalAccess GenerateBadConditionalAccessNodeError(ConditionalAccessExpressionSyntax node, BoundExpression receiver, BoundExpression access, BindingDiagnosticBag diagnostics)

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

@@ -623,7 +623,7 @@ BoundBlock runAnalysis(BoundBlock block, BindingDiagnosticBag blockDiagnostics)
 
         private bool ImplicitReturnIsOkay(MethodSymbol method)
         {
-            return method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(this.Compilation) || method.IsAsyncReturningTaskViaOverride(out _);
+            return method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(this.Compilation);
         }
 
         public BoundStatement BindExpressionStatement(ExpressionStatementSyntax node, BindingDiagnosticBag diagnostics)
@@ -2650,24 +2650,12 @@ protected bool IsTaskReturningAsyncMethod()
             return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningTask(this.Compilation);
         }
 
-        protected bool IsTaskReturningAsyncMethodViaOverride()
-        {
-            var symbol = this.ContainingMemberOrLambda;
-            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningTaskViaOverride(out _);
-        }
-
         protected bool IsGenericTaskReturningAsyncMethod()
         {
             var symbol = this.ContainingMemberOrLambda;
             return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningGenericTask(this.Compilation);
         }
 
-        protected bool IsGenericTaskReturningAsyncMethodViaOverride()
-        {
-            var symbol = this.ContainingMemberOrLambda;
-            return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncReturningGenericTaskViaOverride(out _);
-        }
-
         protected bool IsIAsyncEnumerableOrIAsyncEnumeratorReturningAsyncMethod()
         {
             var symbol = this.ContainingMemberOrLambda;
@@ -2768,7 +2756,7 @@ private BoundStatement BindReturn(ReturnStatementSyntax syntax, BindingDiagnosti
             // on a lambda expression of unknown return type.
             if ((object)retType != null)
             {
-                if (retType.IsVoidType() || IsTaskReturningAsyncMethod() || IsTaskReturningAsyncMethodViaOverride())
+                if (retType.IsVoidType() || IsTaskReturningAsyncMethod())
                 {
                     if (arg != null)
                     {
@@ -2808,7 +2796,7 @@ private BoundStatement BindReturn(ReturnStatementSyntax syntax, BindingDiagnosti
                     if (arg == null)
                     {
                         // Error case: non-void-returning or Task<T>-returning method or lambda but just have "return;"
-                        var requiredType = IsGenericTaskReturningAsyncMethod() || IsGenericTaskReturningAsyncMethodViaOverride()
+                        var requiredType = IsGenericTaskReturningAsyncMethod()
                             ? retType.GetMemberTypeArgumentsNoUseSiteDiagnostics().Single()
                             : retType;
 
@@ -2851,7 +2839,7 @@ internal BoundExpression CreateReturnConversion(
             {
                 Debug.Assert(returnRefKind == RefKind.None);
 
-                if (!IsGenericTaskReturningAsyncMethod() && !IsGenericTaskReturningAsyncMethodViaOverride())
+                if (!IsGenericTaskReturningAsyncMethod())
                 {
                     conversion = Conversion.NoConversion;
                     badAsyncReturnAlreadyReported = true;
@@ -2888,8 +2876,7 @@ internal BoundExpression CreateReturnConversion(
                     if (!badAsyncReturnAlreadyReported)
                     {
                         RefKind unusedRefKind;
-                        if ((IsGenericTaskReturningAsyncMethod() || IsGenericTaskReturningAsyncMethodViaOverride())
-                            && TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
+                        if (IsGenericTaskReturningAsyncMethod() && TypeSymbol.Equals(argument.Type, this.GetCurrentReturnType(out unusedRefKind), TypeCompareKind.ConsiderEverything2))
                         {
                             // Since this is an async method, the return expression must be of type '{0}' rather than 'Task<{0}>'
                             Error(diagnostics, ErrorCode.ERR_BadAsyncReturnExpression, argument.Syntax, returnType);
@@ -3178,7 +3165,7 @@ internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableAr
                     expression = BindToTypeForErrorRecovery(expression);
                     statement = new BoundReturnStatement(syntax, RefKind.None, expression) { WasCompilerGenerated = true };
                 }
-                else if (returnType.IsVoidType() || IsTaskReturningAsyncMethod() || IsTaskReturningAsyncMethodViaOverride())
+                else if (returnType.IsVoidType() || IsTaskReturningAsyncMethod())
                 {
                     // If the return type is void then the expression is required to be a legal
                     // statement expression.

src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs

@@ -40,7 +40,7 @@ public static BoundBlock Rewrite(
 #endif
             var compilation = method.DeclaringCompilation;
 
-            if (method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(compilation) || method.IsAsyncReturningTaskViaOverride(out _))
+            if (method.ReturnsVoid || method.IsIterator || method.IsAsyncReturningTask(compilation))
             {
                 // we don't analyze synthesized void methods.
                 if ((method.IsImplicitlyDeclared && !method.IsScriptInitializer) ||