Need a general way to declare ref and ref-like locals bound to current scope.

[VSadov]

Local references are much less common than returnable ones, so majority of users are ok with the current state.
However when you do need a ref/ref-like variable marked as nonreturnable, or generally bound to current scope, we do not have a good solution.

The default escape of references is the outermost scope ("optimized" for the most common case).

I.E.

Span<T> s;

is the same as

Span<T> s = default;

except the "s" is not definitely assigned.

It becomes a problem in cases when you need to create a variable suitable to accept a local reference with a particular escape scope, but not just yet.

Span<byte> s;

// error. 
// s  is returnable and stackalloc is not
s = stackalloc byte[10];

Current half-solutions

===== Span

For Span<T> and types that it converts to implicitly, the following can be used.

Span<T> s = stackalloc T[0];

But it is only a half-solution.

• s is considered assigned (can be used and could lead to bugs)
• T must be an unmanaged type
• the "current scope" can only be the "top level method scope".

===== ref locals

For ref locals, it is possible to do something like:

    class Program
    {
        static void Main(string[] args)
        {
            ref int y;

            {
                ref int x = ref Dummy<int>(out _);

                // escape error
                y = ref x;
            }
        }

        static ref T Dummy<T>(out T a)
        {
            a = default;
            return ref a;
        }
    }

But it is again a half-solution.

• x is considered assigned (can be used and could lead to bugs)
• needs a dummy helper
• syntax is ugly

[VSadov]

One possible solution could be using underbar " _ " as RHS.

    ref int x = ref _ ;
    // same as the following, but variable is not ref-returnable from the current scope
    ref int x ;

    Span<int> s = _ ;
    // same as the following, but variable is not val-returnable from the current scope
    Span<int> s;

It seems a bit too subtle though.

[stephentoub]

Real-world example where I had to work around this with unsafe code:
https://github.com/dotnet/coreclr/blob/e1a82f16cb8384238b3fb360b773c508c9227415/src/mscorlib/shared/System/Number.Formatting.cs#L75-L80

[alrz]

Span<byte> s;

// error. 
// s  is returnable and stackalloc is not
s = stackalloc byte[10];

If I understand this, the s variable is bound to its scope in Span<T> s = stackalloc ...; and can't be returned?

If so, couldn't we move the "lifetime" of RHS (stackalloc), once it's assigned to LHS (s)?

Span<byte> s;

// fine.
// but `s` is no longer returnable because `stackalloc` is not
s = stackalloc byte[10];

Basically, what we do with Span<T> s = stackalloc ...; but for assignments.

[alrz]

We already do something similar for refs (and later for ref re-assignments)

    ref int M() {
        var local = 42;
        ref var r1 = ref local;
        ref var r2 = ref r1;
        ref var r3 = ref r2
        return ref r3; // error
    }

returnability flows through all assignments.

[VSadov]

The problem is that ref-like variables do not need to be assigned at declaration.
Ideally ordinary refs would be allowed to be initialized later after declaration as well.

The issue is that two levels can be "guessed" and later enforced - outermost/external and innermost/current. But whichever is chosen, there are cases where it would be a wrong guess.
There must be a way for the user to steer the escape value one way or another. Preferably without new syntax.
Possibly by assigning some dummy expression like _

[alrz]

The issue is that two levels can be "guessed" and later enforced

There is no guess, whenever you assign stackalloc to a Span<T> variable, "from that point" it's not returnable anymore (until perhaps it's reassigned to a value that can be returned).

[alrz]

I assume the following is how ref reassignment is going to work,

ref int M() {
    var local = 42;
    ref var r1 = ref local;
    return ref r1; // ERROR
    r1 = ref field;
    return ref r1; // OK
}

If that's correct, we could do something similar with stackalloc here,

Span<byte> s;
s = stackalloc byte[10];
return s; // ERROR
s = new byte[10];
return s; // OK

[VSadov]

That is not how it works though. The escape level of a variable, just like its type when it is var, is inferred form the initializer and does not change.

Span<byte> s;                // Is "s" returnable or not returnable? By default it is.
s = stackalloc byte[10];   // <-- error here, since s is returnable 

[alrz]

The escape level of a variable, just like its type, is inferred from the initializer and does not change.

That's not how it works right now. Why it couldn't be inferred from the value that it has been assigned from, instead of just the "initializer"?

Span<byte> s; // Is "s" returnable or not returnable? By default it is.

Yes that the current situation. But a variable that is not assigned anywhere, cannot be used anyways, right? couldn't we just infer the escape level once it is actually holding a value? (because that's where it actually makes sense and we know that what the escape level should be)

[eludias]

Another suggestion for a work-around for working with a stackalloc but disabling the dreaded CS8350-error without resorting to unsafe is to convert the Span<T> to a ref T, and then convert the ref T back to a Span<T>. This way the compiler does not see the relation between the created Span and the source Span, and therefore assumes it is not on the stack:

public static class SpanExt {
    public static ref T ToRef<T>(this Span<T> src, out int length) {
        length = src.Length;
        return ref MemoryMarshal.GetReference(src);
    }
}

public static class RefExt {
    public static Span<T> ToSpan<T>(this ref T reference, int length) where T : struct => 
        MemoryMarshal.CreateSpan(ref reference, length);
}

Usage:

    Span<byte> bytesOnStack = stackalloc byte[100].ToRef(out len).ToSpan(len);

...now the compiler does not realize that bytesOnStack is allocated on the stack.

Be warned that circumventing the compiler is at your own peril!

[airbreather]

We have scoped now, so I think this can be marked as closed / resolved / answered /whatever it is for discussions?

Span<byte> s;

// error. 
// s  is returnable and stackalloc is not
s = stackalloc byte[10];

scoped Span<byte> t;

// no error. 
t = stackalloc byte[10];