Disallow more locals of restricted type in async methods

[jcouv]

Fixes #62747

The bug was that we allowed declaring locals for restricted type in async methods inside foreach. For example, foreach (Span<int> s in ...) in async methods.
Looking around, I noticed a couple other scenarios with the same issue:

1. deconstruction declarations,
2. using (expression) which lowers to use a temp

[jcouv]

@dotnet/roslyn-compiler for second review. Thanks

[AlekseyTs]

hasErrors = true;

What is our intent here? We don't need to record every possible error in a bound node. The only requirement to set HasError flag is when the node is completely broken. I do not think it is the case here. We were able to bind all things. #Closed

[AlekseyTs]

Setting HasError without a good reason is likely to disable some useful analysis

[jcouv]

This was out of consistency with other callers of CheckRestrictedTypeInAsyncMethod. But I agree this error doesn't prevent us from binding.

[AlekseyTs]

CheckRestrictedTypeInAsyncMethod(originalBinder.ContainingMemberOrLambda, expressionOpt.Type, diagnostics, expressionOpt.Syntax);

Is the wording of the error going to be confusing here?There is no user declared local here #Closed

[AlekseyTs]

var (s3, s4) = new Program();

Consider also testing scenario like (var s5, var s6) = new Program(); #Closed

[AlekseyTs]

// (8,16): error CS4012: Parameters or locals of type 'RS' cannot be declared in async methods or async lambda expressions.

We probably should add a dedicated error for this case, that doesn't talk about locals and parameters #Closed

[AlekseyTs]

using RS s3 = default(RS);

Consider testing var case as well #Closed

[AlekseyTs]

Done with review pass (commit 1)

[AlekseyTs]

Values of type 'RS' cannot be used in async methods or async lambda expressions.

I think that this wording is also confusing, and quite possibly plain incorrect. Values of RS can be used in an async method. For example, the following code compiles today, and I think will continue compiling with changes in this PR, but it is using value of RS type in an async method:
https://sharplab.io/#v2:EYLgtghglgdgNAFxFANgHwAIAYAEGCMArANwCwAUBRgMx4BMe+A7BQN4U6d60YAceANhwBZABQBKDl3bkucvAE5BAOgAiAUxQQAnqPziys+ZwDi6hACUAyhLVQAzgAcA9vfUTDxzhiaeuAXylOIMYhaxwzSxtxHABeAD4cABN1ADMIAFcUBENAynIaHAAnNJx7BCKMgGMEHGs2EMKMABYcVQcXNwkcVhw8/yA===

using System.Threading.Tasks;

public class Program
{
    public async Task M()
    {
        await Task.Delay(1);
        GetRS().Dispose();
        return;
    }
    
    static RS GetRS() => default;
}

public ref struct RS
{
    public void Dispose() { }
}

The problem is that we cannot spill these types, not every usage requires spilling though.

So, I think the wording should be more specific to the situation. I would use something like: "A using statement resource of type 'RS' cannot be used in async methods or async lambda expressions." #Closed

[AlekseyTs]

Or, if we want to have a more general wording, something like: "Values of type 'RS' cannot be used in async methods or async lambda expressions in this context."

[AlekseyTs]

Done with review pass (commit 3)

[AlekseyTs]

reportOnTemp

forUsingExpression?

[AlekseyTs]

LGTM (commit 4), with a parameter rename suggestion