using + struct indexer emits CS1654, why?

[andanteyk]

Combining using with a struct indexer will result in a compilation error.
This will not occur if you manually Dispose() it or implement it with a try-finally pattern.

It seems to me that the compiler is behaving strangely. I'd like to know why.

public static class MainClass
{
    static void Main()
    {
        {
            // manually Dispose - OK
            var str = new RefStruct(stackalloc int[1]);
            str[0] = 42;
            str.Values[0] = 42;
            str.Dispose();
        }

        {
            // try-finally Dispose - OK
            var str = new RefStruct(stackalloc int[1]);
            try
            {
                str[0] = 42;
                str.Values[0] = 42;
            }
            finally
            {
                str.Dispose();
            }
        }

        {
            // using - NG
            using (var str = new RefStruct(stackalloc int[1]))
            {
                str[0] = 42; // error CS1654

                str.Values[0] = 42; // valid
            }
        }

        {
            // using var - NG
            using var str = new RefStruct(stackalloc int[1]);
            str[0] = 42; // error CS1654

            str.Values[0] = 42; // valid
        }
    }
}

ref struct RefStruct
{
    public Span<int> Values;

    public RefStruct(Span<int> buffer) => Values = buffer;
    public int this[int index]
    {
        readonly get => Values[index];
        set => Values[index] = value;
    }
    public void Dispose() { /* something */ }
}

---

dotnet --version: 10.0.100-alpha.1.24623.5
maybe related: #68882

[CyrusNajmabadi]

A using variable is defined to be readonly in the C# language specification. https://github.com/dotnet/csharpstandard/blob/standard-v6/standard/statements.md#1214-the-using-statement

Local variables declared in a resource_acquisition are read-only, and shall include an initializer. A compile-time error occurs if the embedded statement attempts to modify these local variables

Your code is attempting to modify the local variable as we define writing into an indexer on a struct as a mutation of it. If you want the compiler to view things differently, a change would have to happen to the language. Such changes start with a discussion at dotnet/csharplang. Thanks!

[andanteyk]

Thank you for your reply.
I see, I understand that using resources are readonly.

But according to the link you provided,

When ResourceType is a non-nullable value type or a type parameter with the value type constraint (§14.2.5), the expansion is semantically equivalent to

{
    ResourceType resource = «expression»;
    try
    {
        «statement»;
    }
    finally
    {
        ((IDisposable)resource).Dispose();
    }
}

But isn't it a contradiction that one passes and the other doesn't?

Why is it that calling methods / writing to its property that inherently mutate internal state is permitted, so indexers fail?
(It makes sense that reassignment would be forbidden - it's readonly.)

[CyrusNajmabadi]

the expansion is semantically equivalent to

Semantically equivalent with the additional stated requirements.

so indexers fail?

A choice we made back in C# 1.0. We thought it sensible at the time.

[andanteyk]

A choice we made back in C# 1.0.

I see, that's sad but can't be helped.
I understand, and thank you again!

[CyrusNajmabadi]

I see, that's sad but can't be helped.

Well, it can be. If the lang is changed in a future update :) That just happens elsewhere, not here. :)

[andanteyk]

{
   using (var str = new RefStruct(stackalloc int[1]))
    {
        // What's the difference?
        str[0] = 42; // error CS1654
        str.Items(0) = 42; // valid
    }
}

ref struct RefStruct
{
    // ...
    public ref int Items(int index) { return ref Values[index]; }
}

[CyrusNajmabadi]

/ What's the difference?

There is no rule that a ref-returning method cannot be called on a readonly value. There is that a setter cannot. It's as simple as that. If you'd like this changed, it would need a spec change ratified at dotnet/csharplang. The compiler is just implementing the rules as specified :)