Error clarity: Cannot pass stack allocated spans to instance methods on ref struct

[KrzysztofCwalina]

Version Used:
7.2

Steps to Reproduce:

class Program
{
    static void Main()
    {
        Span<byte> bytes = stackalloc byte[10];
        var foo = new Foo();
        foo.Bar(bytes);
    }
}

ref struct Foo
{
    public void Bar(Span<byte> buffer) {
        Console.WriteLine(buffer.Length);
    }
}

Expected Behavior:
The program should compile fine (possibly with some modifications/annotations.

Actual Behavior:
Error CS8350 This combination of arguments to 'Foo.Bar(Span)' is disallowed because it may expose variables referenced by parameter 'buffer' outside of their declaration scope ConsoleApp5 C:\Users\Krzysztof\Documents\Visual Studio 2017\Projects\ConsoleApp5\ConsoleApp5\Program.cs 9 Active

[jcouv]

Tagging @VSadov

[jcouv]

Ping @VSadov

[VSadov]

This is ByDesign as we have discussed. Either the struct must be readonly or the method must be a static method taking both instance and argument byval, or the method must be an in extension method on the struct.

Otherwise nothing stops the method from doing this.SomePart = buffer and corrupting the returnable instance with unreturnable data.
Compiler prevents that from happening, but error could be be clearer.

[KrzysztofCwalina]

It would be nice if I could somehow indicate I won't store the buffer in a field, e.g.:

    public void Bar(Span<byte> buffer) readonly {
        Console.WriteLine(buffer.Length);
    }

[VSadov]

Individually readonly members could help too. As long as one knows what is wrong.
A post-modifier ‘readonly’ might be one of possible syntaxes. It is a whole new feature though.

[KrzysztofCwalina]

Another idea (from @pakrym) would be to simply allow calling such members as long as they are marked unsafe:

public unsafe void Bar(Span<byte> buffer) {
        Console.WriteLine(buffer.Length);
}

[jcouv]

@KrzysztofCwalina Since this is currently by-design, I'll go ahead and close this issue.
Feel free to open a csharplang issue if there is a language proposal to discuss. Thanks

[tmds]

I'm trying to implement a TryAppend method that takes a ReadOnlySpan<byte> and I'm hitting this issue.

    public unsafe ref struct SpanWriter
    {
        // private ...
        public bool TryAppend(ReadOnlySpan<byte> data)
        {
            // ...
        }
    }

I guess I can't workaround this since I don't want to make my struct readonly.

[KrzysztofCwalina]

@tmd, I think you can workaround this by changing the method to a static method.

        public static bool TryAppend(SpanWriter writer, ReadOnlySpan<byte> data)
        {
            // ...
        }

[naine]

For the benefit of others who come across this:

Problem with the workaround above is that the method presumably has to modify a position field within the SpanWriter, or maybe replace the span it holds with a slice of the unwritten portion. So it either has to be a non-readonly instance method or take the instance byref, either way getting CS8350.

Another workaround, if you know the implementation will not save the span and only copy from it, is to trick the compiler by recreating it:

TryAppend(MemoryMarshal.CreateReadOnlySpan(ref MemoryMarshal.GetReference(span), span.Length)); // No CS8350

Obviously this is unsafe.

[darren-clark]

I ran into this trying to make an extension method on SequenceReader<byte> that would call both CopyTo and Advance for convenience. With stackalloc span. So I need to have the reader by ref, and it seems that it's "safe", but not sure if I can convince the compiler.

[eiriktsarpalis]

I bumped into this issue when doing prototyping work for dotnet/runtime#54410. It would be nice if we could somehow indicate that the buffer will never be stored in the ref struct, even if it means marking the method as unsafe.