Why is Point.Offset() not giving a compiler error in a readonly struct?

Question

Perhaps I'm misunderstanding the concept of a readonly struct, but I would think this code should not compile:

public readonly struct TwoPoints
{
    private readonly Point one;
    private readonly Point two;

    void Foo()
    {
        // compiler error:  Error CS1648  Members of readonly field 'TwoPoints.one'
        // cannot be modified (except in a constructor or a variable initializer)
        one.X = 5;

        //no compiler error! (and one is not changed)
        one.Offset(5, 5);
    }
 }

(I'm using C# 7.3.) Am I missing something?

Answer 1

There is no way for compiler to figure out that Offset method mutates Point struct members. However, readonly struct field is handled differently compared to non-readonly one. Consider this (not readonly) struct:

public struct TwoPoints {
    private readonly Point one;
    private Point two;

    public void Foo() {
        one.Offset(5, 5); 
        Console.WriteLine(one.X); // 0
        two.Offset(5, 5);
        Console.WriteLine(two.X); // 5
    }
}

one field is readonly but two is not. Now, when you call a method on readonly struct field - a copy of struct is passed to that method as this . And if method mutates struct members - than this copy members are mutated. For this reason you don't observe any changes to one after method is called - it has not been changed but copy was.

two field is not readonly, and struct itself (not copy) is passed to Offset method, and so if method mutates members - you can observe them changed after method call.

So, this is allowed because it cannot break immutability contract of your readonly struct . All fields of readonly struct should be readonly , and methods called on readonly struct field cannot mutate it, they can only mutate a copy.

If you are interested in "official source" for this - specification (7.6.4 Member access) says that:

If T is a struct-type and I identifies an instance field of that struct-type:

• If E is a value, or if the field is readonly and the reference occurs outside an instance constructor of the struct in which the field is declared, then the result is a value, namely the value of the field I in the struct instance given by E.

• Otherwise, the result is a variable, namely the field I in the struct instance given by E.

T here is target type, and I is member being accessed.

First part says that if we access instance readonly field of a struct, outside of constructor, the result is value . In second case, where instance field is not readonly - result is variable .

Then section "7.5.5 Function member invocation" says ( E here is instance expression, so for example one and two above):

• If M is an instance function member declared in a value-type:

If E is not classified as a variable, then a temporary local variable of E's type is created and the value of E is assigned to that variable. E is then reclassified as a reference to that temporary local variable. The temporary variable is accessible as this within M, but not in any other way. Thus, only when E is a true variable is it possible for the caller to observe the changes that M makes to this.

As we saw above, readonly struct field access results in a value , not a variable and so, E is not classified as variable.

Answer 2

Supporting the answer from Evk , there is an article in regards the Point's method: Point.Offset()

Note that calling the Offset method will only have an effect if you can change the X and Y properties directly. Because Point is a value type, if you reference a Point object by using a property or indexer, you get a copy of the object, not a reference to the object. If you attempt to change X or Y on a property or indexer reference, a compiler error occurs. Similarly, calling Offset on the property or indexer will not change the underlying object. If you want to change the value of a Point that is referenced as a property or indexer, create a new Point, modify its fields, and then assign the Point back to the property or indexer.

---

By the definition Point is declared as struct : Point

Last but not least, there is an article on Microsoft's blog, which describes that readonly fields , that are actually struct , their public properties are read-only also.

A read-only struct is a struct whose public members are read-only , as well as the “this” parameter.