Edit-and-continue changes async codegen; make it configurable

[jthorborg]

async/await and "task-like" friends is a really interesting system that actually allows to conjure a completely unmanaged stackless coroutine system, without ever involving the GC. This allows to build performant graph processing systems for games that do not suffer from recursion (and thereby stack overflow) for instance.

Unfortunately, the lowering of the feature changes codegen when running compiling under debug in an effort to support edit and continue - specifically the generated closure is a class under debug:
https://github.com/dotnet/roslyn/blob/master/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.cs#L68

This makes it impossible to constrain generic arguments in methods in the builder pointed to by AsyncMethodBuilder to be : unmanaged.

Worse, lowering happens after proposed source generation and compilation checks before assembly is emitted, so the usual suspects like Cecil cannot be employed to solve this.

I'm working in a domain where edit and continue would never work anyway, so a reasonable compromise could be having a compiler flag for overriding whether EnC is enabled, looks like CompilationOptions was already encapsulating this perhaps with that in mind?

Thanks for any thoughts!

[tmat]

Could you share a self-contained code snippet that you'd like to compile that does not today?

[jthorborg]

Here you go, also on sharplab:

using System;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;

[StructLayout(LayoutKind.Sequential)]
public struct OpBuilder<T>
    where T : unmanaged
{
    Routine<T> m_Request;

    public static unsafe OpBuilder<T> Create() => default;

    public Routine<T> Task => m_Request;

    public void SetResult(T results) { }

    public unsafe void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : unmanaged, INotifyCompletion
        where TStateMachine : unmanaged, IAsyncStateMachine
    {
    
    }

    public unsafe void Start<TStateMachine>(ref TStateMachine stateMachine)
        where TStateMachine : unmanaged, IAsyncStateMachine
    {

    }

    public void SetException(Exception e) { }

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
    }
    public void SetStateMachine(IAsyncStateMachine stateMachine) => throw new NotImplementedException();
}

[AsyncMethodBuilder(typeof(OpBuilder<>))]
[StructLayout(LayoutKind.Sequential)]
public unsafe struct Routine<T>
    where T : unmanaged
{
    public Awaiter GetAwaiter() => new Awaiter(this);

    public struct Awaiter : INotifyCompletion
    {
        Routine<T> m_Request;

        public Awaiter(Routine<T> taskLike)
        {
            m_Request = taskLike;
        }

        public T GetResult() => default;

        public bool IsCompleted => default;

        public void OnCompleted(Action continuation) => throw new NotImplementedException();
    }
}

public class C
{
    public async Routine<int> Main()
    {
        return 5;
    }
    
}

It works fine in release but not in debug.

[tmat]

Filed an issue: #51234

[tmat]

The issue describes the necessary fix. If you're interested in fixing this we'd accept a PR.

[jthorborg]

Thanks for writing that up, I think it's a better approach than what I suggested for sure.
Changes to async in the compiler seems straightforward, and I'll take a look to see if it's something I can reasonably whip up. I'm not sure about integration about the IDE and how that works though, perhaps I'll stumble upon that during investigation.