Relax CS4010 for IAsyncEnumerable

[yaakov-h]

I have the following code in a unit test that I am trying to write:

mockFirstAnalyzer.Setup(x => x.FindRelicsAsync(It.IsAny<string>(), It.IsAny<CancellationToken>()))
    .Returns(async () =>
    {
        await Task.Yield();
        throw new InvalidOperationException("I don't like this one.");
    });

This results in the following:

Error: CS4010 Cannot convert async lambda expression to delegate type 'Func<IAsyncEnumerable<Relic>>'. An async lambda expression may return void, Task or Task<T>, none of which are convertible to 'Func<IAsyncEnumerable<Relic>>'

As a workaround I can move this to a local function and/or an object-level function:

static async IAsyncEnumerable<TResult> ThrowAsyncEnumerable<TResult>(Exception exception)
{
    await Task.Yield();
    throw exception;
}

However, I'd like to be able to create IAsyncEnumerable lambdas and delegates the same way that I can create Task-based ones easily.

IAsyncEnumerable isn't a custom awaitable, it is one that the compiler already knows how to emit as per the C# 8.0 language spec, though it may be worth seeing if the LDM has any interest in extending this to custom awaitable types.

With that said, though, my function throws and does not return. For lambdas or delegates that return an actual value rather than just throwing, this may brush up against CS1621 "The yield statement cannot be used inside an anonymous method or lambda expression".

[yaakov-h]

Actually, my workaround seems to trigger another error:

error CS8419: The body of an async-iterator method must contain a 'yield' statement.

IAsyncEnumerable feels a bit rough around the edges...

[333fred]

@jcouv, was this an intentional restriction?

[jcouv]

Yes, that's intentional:
https://github.com/dotnet/csharplang/blob/main/proposals/csharp-8.0/async-streams.md#syntax-1

That's a similar restriction to regular iterators, which are defined by the existence of "iterator blocks" (ie. blocks with a yield):
https://github.com/dotnet/csharplang/blob/main/spec/statements.md#blocks

yield break will do the trick, but as with regular iterators there's probably helper libraries to do something better (return Enumerable<...>.Empty; for non-async case).

[yaakov-h]

yield break doesn't help when you want to throw, and I haven't yet found an AsyncEnumerable.FromException(...) helper library.

I guess I might have to write it 😅