Improve async iterator diagnostic by removing redundant error

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

@@ -185,9 +185,21 @@ private bool ReportBadAwaitWithoutAsync(SyntaxNodeOrToken nodeOrToken, BindingDi
                         }
                         else
                         {
-                            info = method.ReturnsVoid ?
-                                new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutVoidAsyncMethod) :
-                                new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, method.ReturnType);
+                            if (method.ReturnsVoid)
+                            {
+                                info = new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutVoidAsyncMethod);
+                            }
+                            else if (method.IsIterator && 
+                                     (method.ReturnType.IsIAsyncEnumerableType(Compilation) || 
+                                      method.ReturnType.IsIAsyncEnumeratorType(Compilation)))
+                            {
+                                // For async iterators, don't suggest changing the return type
+                                info = new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutAsyncIterator);
+                            }
+                            else
+                            {
+                                info = new CSDiagnosticInfo(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, method.ReturnType);
+                            }
                         }
                         break;
                 }

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -3797,6 +3797,9 @@ Give the compiler some way to differentiate the methods. For example, you can gi
   <data name="ERR_BadAwaitWithoutVoidAsyncMethod" xml:space="preserve">
     <value>The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task'.</value>
   </data>
+  <data name="ERR_BadAwaitWithoutAsyncIterator" xml:space="preserve">
+    <value>The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier.</value>
+  </data>
   <data name="ERR_BadAwaitInFinally" xml:space="preserve">
     <value>Cannot await in the body of a finally clause</value>
   </data>

src/Compilers/CSharp/Portable/Errors/ErrorCode.cs

@@ -1136,9 +1136,10 @@ internal enum ErrorCode
         ERR_BadAwaitWithoutAsyncLambda = 4034,
         // ERR_BadAwaitWithoutAsyncAnonMeth = 4035,         Merged with ERR_BadAwaitWithoutAsyncLambda in Roslyn
         ERR_NoSuchMemberOrExtensionNeedUsing = 4036,
+        ERR_BadAwaitWithoutAsyncIterator = 4037,
         #endregion diagnostics introduced in C# 5
 
-        // unused 4037-4999
+        // unused 4038-4999
 
         #region diagnostics introduced in C# 6
         // WRN_UnknownOption = 5000,   //unused in Roslyn

src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs

@@ -1573,6 +1573,7 @@ or ErrorCode.ERR_SecurityCriticalOrSecuritySafeCriticalOnAsyncInClassOrStruct
                 or ErrorCode.ERR_BadAwaitWithoutAsyncMethod
                 or ErrorCode.ERR_BadAwaitWithoutVoidAsyncMethod
                 or ErrorCode.ERR_BadAwaitWithoutAsyncLambda
+                or ErrorCode.ERR_BadAwaitWithoutAsyncIterator
                 or ErrorCode.ERR_NoSuchMemberOrExtensionNeedUsing
                 or ErrorCode.ERR_UnexpectedAliasedName
                 or ErrorCode.ERR_UnexpectedGenericName

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncIteratorTests.cs

@@ -1997,12 +1997,34 @@ static System.Collections.Generic.IAsyncEnumerator<int> M(int value)
                 // (4,61): error CS8403: Method 'C.M(int)' with an iterator block must be 'async' to return 'IAsyncEnumerator<int>'
                 //     static System.Collections.Generic.IAsyncEnumerator<int> M(int value)
                 Diagnostic(ErrorCode.ERR_IteratorMustBeAsync, "M").WithArguments("C.M(int)", "System.Collections.Generic.IAsyncEnumerator<int>").WithLocation(4, 61),
-                // (7,9): error CS4032: The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task<IAsyncEnumerator<int>>'.
+                // (7,9): error CS4037: The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier.
                 //         await System.Threading.Tasks.Task.CompletedTask;
-                Diagnostic(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, "await System.Threading.Tasks.Task.CompletedTask").WithArguments("System.Collections.Generic.IAsyncEnumerator<int>").WithLocation(7, 9)
+                Diagnostic(ErrorCode.ERR_BadAwaitWithoutAsyncIterator, "await System.Threading.Tasks.Task.CompletedTask").WithLocation(7, 9)
                 );
+        }
 
-            // This error message is rather poor. Tracked by https://github.com/dotnet/roslyn/issues/31113
+        [Fact]
+        [WorkItem(31057, "https://github.com/dotnet/roslyn/issues/31057")]
+        [WorkItem(31113, "https://github.com/dotnet/roslyn/issues/31113")]
+        public void AsyncIteratorReturningEnumerable_WithoutAsync()
+        {
+            string source = @"
+class C
+{
+    static System.Collections.Generic.IAsyncEnumerable<int> M(int value)
+    {
+        yield return value;
+        await System.Threading.Tasks.Task.CompletedTask;
+    }
+}";
+            var comp = CreateCompilationWithAsyncIterator(source);
+            comp.VerifyDiagnostics(
+                // (4,61): error CS8403: Method 'C.M(int)' with an iterator block must be 'async' to return 'IAsyncEnumerable<int>'
+                //     static System.Collections.Generic.IAsyncEnumerable<int> M(int value)
+                Diagnostic(ErrorCode.ERR_IteratorMustBeAsync, "M").WithArguments("C.M(int)", "System.Collections.Generic.IAsyncEnumerable<int>").WithLocation(4, 61),
+                // (7,9): error CS4037: The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier.
+                //         await System.Threading.Tasks.Task.CompletedTask;
+                Diagnostic(ErrorCode.ERR_BadAwaitWithoutAsyncIterator, "await System.Threading.Tasks.Task.CompletedTask").WithLocation(7, 9));
         }
 
         [Fact]