Proposal: allow scoped ref locals within async and iterator methods

[vasiliuk]

Example:

async void Method<T>(T[] arg) where T : new
{
    for (int i = 0; i < arg.Length; i++)
    {
        await Task.Yield();
        {
            // following ref-local wont be leaked away from this sync scope
            ref T p = ref arg[i];
            p = new T();
        }
    }
}

[ufcpp]

static IEnumerator Iterator()
{
    Span<byte> buf = stackalloc byte[1]; // this is allowed in VS 15.5
    buf[0] = 1;

    yield return null;

    Span<byte> bufOverYield = stackalloc byte[1];

    yield return null;

    bufOverYield[0] = 1; // this is not.
}

So,

• ref locals should also be allowed
• These should be allowed in async methods

[vasiliuk]

to @ufcpp :
syntaxical visibility of buff extended to the code past yield ... which obviously incorrect. while mine proposal - just easy workaround

[MrJul]

In iterators, this already works currently, as long as the variable isn't hoisted (isn't used before and after a yield):

// Compiles
IEnumerator M() {
    Span<byte> buf = stackalloc byte[1];
    buf[0] = 1;
    yield return null;
}

// Does not compile and that's expected
IEnumerator M() {
    Span<byte> buf = stackalloc byte[1];
    yield return null;
    buf[0] = 1; // error CS4013
}

So let's focus on async methods, where this doesn't compile:

// Does not compile, but could
async void M() {
    Span<byte> buf = stackalloc byte[1]; // error CS4012
    buf[0] = 1;
    await Task.Yield();
}

The difference between iterators and async methods is small, both are compiled to a state machine and share a bunch of the same code generation. Async methods have some extras preliminary checks, where any restricted type (ref structs, TypedReference, etc.) isn't allowed as a parameter or a local.

So I've tried to remove this limitation, and to my surprise this was really easy, by simply removing the locals check: https://github.com/MrJul/roslyn/commit/aa9184da4448457030a5c24e47426fe4627cb51c

With the changes:

// Now compiles
async void M() {
    Span<byte> buf = stackalloc byte[1];
    buf[0] = 1;
    await Task.Yield();
}

// Does not compile and that's expected
async void M() {
    Span<byte> buf = stackalloc byte[1];
    await Task.Yield();
    buf[0] = 1; // error CS4013
}

The existing state machine transformation code is used in both places, and a CS4013 error is generated as soon as the local escapes, so everything works as expected.

Note that this doesn't change the rule for restricted parameters, because they would have to be used only before the first await, which doesn't seem useful.

This change has two other impacts:

• Some error tests are now failing because what they contain is now valid code, and they should be fixed.
• CS4013 is triggered at emit phase (CS4012 was at binding phase).

[MrJul]

Is this useful?

With more types becoming ref structs, such as Utf8JsonWriter, allowing the following code doesn't seem too far fetched to me:

async Task ExportSomeJsonAsync() {
   var data = await GetDataAsync();
   var writer = new Utf8JsonWriter();
   // use writer to write data
   ...
}

[vasiliuk]

IMHO this is very useful. At this moment you have to create another method which will do that "synchronous" data manipulation for you. Would be nice to have ability to work with ref structs inside async and iterator methods. But as i mentioned - usage (as well as visibility of declared ref variables) could be limited in between different async/yield steps. The best way to do so is force developer to limit its visibility by scope bracers so your code will be like:

async Task ExportSomeJsonAsync() {
   var data = await GetDataAsync();
   { 
      // you can use refs inside this scope as long as you dont use any yield or await methods within it
      var writer = new Utf8JsonWriter();
      // use writer to write data
      ...
   }
}

[GazziFX]

Sadly, it's still not implemented