C# ref local and returns are not allowed on async methods

[BillWagner]

This follows the same logic as why ref and out arguments are not allowed on async methods, but we should state it explicitly in the "what's new in C# 7" topic, and where we describe the ref keyword.

/cc @rpetrusha

[guardrex]

@BillWagner @rpetrusha

Seems like this falls (loosely) under the rule:

You cannot return a ref to a variable whose lifetime does not extend beyond the execution of the method.

That's the prob, isn't it? ... that the referenced var may go out-of-scope if async were to be allowed (without a major rework of the way async works)?

... if that's correct, then I wonder if the sub-bullet line could be extended, such as ...

• You cannot return a ref to a variable whose lifetime does not extend beyond the execution of the method.
  • That means you cannot return a reference to a local variable or variable with a similar scope. Similarly, ref locals and returns cannot be used with async methods, as the locally referenced variable may go out-of-scope before the async method returns.

... or perhaps a 3rd rule can be added there (perhaps with a sub-bullet) ...

• You cannot use ref locals and returns with async methods.
  • A locally referenced variable may go out-of-scope before the async method returns.

[guardrex]

@BillWagner Do you like one of those approaches ☝️, or should I go a different way with it?

[BillWagner]

@guardrex We should add the third rule.

And, it's not about the local going out of scope: it's because the method may return before all it's work is done. Consider this (contrived) example:

public async Task SetArgument(ref int answer)
{
   answer = await FindValueAsync();
}

The compiler cannot know if answer has been set before the method returns. That fact is only known at runtime.

Or, to modify the sample in the What's new article:

// NOT VALID C#:
public static Task<ref int> Find2(int[,] matrix, Task<Func<int, bool>> predicate)
{
    for (int i = 0; i < matrix.GetLength(0); i++)
        for (int j = 0; j < matrix.GetLength(1); j++)
            if (await predicate(matrix[i, j]))
                return matrix[i, j];
    throw new InvalidOperationException("Not found");
}

The justification for the rule is more about definite assignment and less about scope.

[guardrex]

The compiler cannot know if answer has been set before the method returns.

Do you mean the compiler cannot know if answer has been set by the caller (or anywhere outside of the Task) before the method returns?

[guardrex]

If that's correct, then the logic (not necessarily the text) would be more like ...

• You cannot use ref locals and returns with async methods.
  • A locally referenced variable may be out-of-scope before the async method returns.

... with "out-of-scope" meaning in this case "doesn't exist" as opposed to losing scope of something that did exist at one time.

-- or perhaps better (formatted more like rule 2) ...

• You cannot return a ref to a variable that doesn't exist when the method is ready to set or return the reference.
  • That means you cannot use ref locals and returns with async methods because the compiler cannot know if the referenced variable has been set by the caller (or anywhere outside of the method) before the async method would return.

[rpetrusha]

@guardrex, I'll modify the documentation for the ref keyword to note this, since I'm working on documenting ref locals and ref returns.