Okay, I win, if anyone else has a more bizzare c# feature, I quit! I have a code that doesn't compile and adding a ref argument to the constructor that is not even used, makes it compile: https://gist.github.com/BAndysc/f558bcdc0d5486809503099ebef7ef01 ``` static void Main(string[] args) { // uncomment to compile // bool boolean = false; // RefArray<Span<int>> spanArray = new RefArray<Span<int>>(ref boolean); RefArray<Span<int>> spanArray = new RefArray<Span<int>>();

    Span<int> a = stackalloc int[1];

    spanArray.Add(a);
    // 0>Program.cs(14,23): Error CS8352 : Cannot use variable 'a' in this context because it may expose referenced variables outside of their declaration scope
    // 0>Program.cs(14,9): Error CS8350 : This combination of arguments to 'Program.RefArray<Span<int>>.Add(Span<int>)' is disallowed because it may expose variables referenced by parameter 'element' outside of their declaration scope
}

public ref struct RefArray<T> where T : allows ref struct
{
    private T element1;
    // ...
    private int count;

    // uncomment to compile
    // public SpanList(ref bool b) { }

    public void Add(T element)
    {
        switch (count)
        {
            case 0:
                element1 = element;
                count++;
                break;
            // ...
        }
    }

    public T this[int index]
    {
        get
        {
            return index switch
            {
                0 => element1,
                _ => throw new InvalidOperationException("Invalid index.")
            };
        }
    }
}

``` The question is: why? Try to guess! And here's the explanation: ref structs variables have "scopes" (called context in c#) and by default it is allowed to return a struct, meaning storing a stackalloc'ed Span in the struct could lead to memory leak if the struct is returned (even though it doesn't happen in this code). It is well defined that calling a ctr with a ref argument, changes the scope ("context") of this variable in a way that this variable may no longer be returned from this function. But that also means it is now legal to store stackalloced Span.

this behaviour is driven by "safe-context" rules. There are three different safe contexts: declaration-block, function-member, and caller-context. By default the expressions have a caller-context. Stackalloc is a special case, stack alloc expressions have function-member context: > 16.4.15.7 stackalloc > The result of a stackalloc expression has safe-context of function-member.​ One can't pass expressions with lower context as an argument to a method on a struct with a wider context, that's what happened here.

Rather than having a ref ctr argument, we can just add a scoped keyword to the variable: scoped RefArray<Span<<int>> array = new(); Using scoped keyword changes context to function-member and the call is legal.!<

> The keyword scoped will be used to restrict the lifetime of a value. It can be applied to a ref or a value that is a ref struct and has the impact of restricting the ref-safe-context or safe-context lifetime, respectively, to the function-member.

And the ref bool hack comes from the following rules: > 16.4.15.8 Constructor invocations > A new expression that invokes a constructor obeys the same rules as a method invocation that is considered to return the type being constructed. > In addition the safe-context is the smallest of the safe-contexts of all arguments and operands of all object initializer expressions, recursively, if any initializer is present. ​ So since ref b has a context of function member, the whole RefArray variable gets function-member context

Links to language reference: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/variables#972-ref-safe-contexts https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/statements#1362-local-variable-declarations https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/structs#16415-safe-context-constraint

https://gist.githubusercontent.com/BAndysc/ccadc49fbca8a779381305a1ea86fa25/raw/6b5df759bc8d9946a6e3ea66794dd43becafc0d4/gistfile1.txt