Improve async iterator diagnostic by removing redundant error

[Copilot]

Improvement to async iterator diagnostics - Complete ✅

This PR improves the diagnostic experience when an async iterator method (returning IAsyncEnumerable<T> or IAsyncEnumerator<T>) with yield statements is missing the async keyword.

Before:
Two redundant errors were reported:

error CS8403: Method 'C.M(int)' with an iterator block must be 'async' to return 'IAsyncEnumerator<int>'
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>>'.

❌ Multiple errors with incorrect return type suggestion

After:
Single, clear error message:

error CS8403: Method 'C.M(int)' with an iterator block must be 'async' to return 'IAsyncEnumerator<int>'

✅ One focused error without incorrect return type suggestion

Changes

• Modified Binder_Await.cs to skip reporting await errors for async iterators since ERR_IteratorMustBeAsync is already reported by ExecutableCodeBinder.ValidateIteratorMethod
• Uses shared InMethodBinder.IsAsyncStreamInterface method to ensure consistent detection logic
• This eliminates redundant error messages and improves the diagnostic experience
• Added explanatory comment referencing where the primary error is reported
• Updated tests to expect only one error (ERR_IteratorMustBeAsync) instead of two
• Added test coverage for both IAsyncEnumerable<T> and IAsyncEnumerator<T> cases

Test Results

• All 14 async iterator "returning" tests pass ✅
• All 285 async iterator tests pass ✅

Fixes #31113

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Async-streams: improve diagnostic when missing async keyword</issue_title>
<issue_description>```C#
[ConditionalFact(typeof(WindowsDesktopOnly))]
[WorkItem(31057, "https://github.com//issues/31057")]
public void AsyncIteratorReturningEnumerator_WithoutAsync()
{
string source = @"
class C
{
static System.Collections.Generic.IAsyncEnumerator M(int value)
{
yield return value;
await System.Threading.Tasks.Task.CompletedTask;
}
}";
var comp = CreateCompilationWithTasksExtensions(new[] { source, s_common });
comp.VerifyDiagnostics(
// (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>'.
// await System.Threading.Tasks.Task.CompletedTask;
Diagnostic(ErrorCode.ERR_BadAwaitWithoutAsyncMethod, "await System.Threading.Tasks.Task.CompletedTask").WithArguments("System.Collections.Generic.IAsyncEnumerator").WithLocation(7, 9)
);
}

We can probably also improve this error (missing `IAsyncEnumerable<T>` or `IAsyncEnumerator<T>` type):
```C#
        [Fact]
        public void MissingTypeAndMembers_IAsyncEnumerator()
        {
...          
            VerifyMissingType(_enumerator, WellKnownType.System_Collections_Generic_IAsyncEnumerator_T,
                // (5,60): error CS1983: The return type of an async method must be void, Task, Task<T>, a task-like type, or IAsyncEnumerable<T>
                //     async System.Collections.Generic.IAsyncEnumerator<int> M() { await Task.CompletedTask; yield return 3; }
                Diagnostic(ErrorCode.ERR_BadAsyncReturn, "M").WithLocation(5, 60),
                // (5,60): error CS1624: The body of 'C.M()' cannot be an iterator block because 'IAsyncEnumerator<int>' is not an iterator interface type
                //     async System.Collections.Generic.IAsyncEnumerator<int> M() { await Task.CompletedTask; yield return 3; }
                Diagnostic(ErrorCode.ERR_BadIteratorReturn, "M").WithArguments("C.M()", "System.Collections.Generic.IAsyncEnumerator<int>").WithLocation(5, 60)
                );
...
        }
```</issue_description>

<agent_instructions>@copilot see if you can improve things here.  The issue is stating:

```c#
and changing its return type to 'Task<IAsyncEnumerator<int>>'.

Because tehre is a 'yield' statement in the method the correct return type is IAsyncEnumerator<> or IAsyncEnumerable<>. If the method already has one of tehse return types, we should just limit the error to say that 'async' should be added, and not the changing of the return type.</agent_instructions>

Comments on the Issue (you are @copilot in this section)

• Fixes Async-streams: improve diagnostic when missing async keyword #31113

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[CyrusNajmabadi]

@copilot instead of a new error, can you use ERR_BadAwaitWithoutAsync? #Closed

[Copilot]

Done in 3de3769. Using ERR_BadAwaitWithoutAsync which provides a simpler message without suggesting a return type change.

[CyrusNajmabadi]

@copilot use raw string literals.

[Copilot]

Done in cac74c6. Converted both tests to use raw string literals and updated the line numbers in diagnostic expectations.

[CyrusNajmabadi]

@copilot add test with IAsyncEnumerator<...> as well. #Closed

[Copilot]

Both test cases are already present:

• AsyncIteratorReturningEnumerator_WithoutAsync (line 1984) tests IAsyncEnumerator<int>
• AsyncIteratorReturningEnumerable_WithoutAsync (line 2008) tests IAsyncEnumerable<int>

Both were added in commit 4ea5dc9.

[CyrusNajmabadi]

@copilot fix formatting errors (excess spaces on line). #Closed

[Copilot]

Done in b7d326e. Removed trailing whitespace from lines 192-194.

[CyrusNajmabadi]

@copilot keep the original test string for tests you're updating. For new tests you can use raw-strings. #Closed

[Copilot]

Done in 3b78eef. Reverted the existing AsyncIteratorReturningEnumerator_WithoutAsync test to use verbatim strings. Only the new AsyncIteratorReturningEnumerable_WithoutAsync test uses raw string literals.

[CyrusNajmabadi]

@copilot do we even need this error? It looks like we already report error CS8403: Method 'C.M(int)' with an iterator block must be 'async' to return 'IAsyncEnumerable<int>'. Since we already have that error, can we just not report this error on await? If so, update the code to check for that and not report, but give a comment in the code explaining why that's ok. #Closed

[Copilot]

Done in a5766a3. Since ERR_IteratorMustBeAsync already tells the user to add 'async', we now skip reporting the await error to avoid redundancy. Added a comment explaining why this is okay.

[CyrusNajmabadi]

@copilot mention which method reports this ERR_IteratorMustBeAsync error. Also, if possible, can we share code between that location and this location to ensure that we're checking all the same conditions to report an error there and not report an error here? #Closed

[Copilot]

Done in 5b4c38e. Now using the shared InMethodBinder.IsAsyncStreamInterface method to ensure we check the same conditions, and updated the comment to mention ExecutableCodeBinder.ValidateIteratorMethod as the location that reports the error.

[CyrusNajmabadi]

@dotnet/roslyn-compiler ptal.

[jcouv]

LGTM Thanks (commit 11)