“Defensive” copies – standardising a compiler strategy or language semantics?

[Nigel-Ecma]

@KalleOlaviNiemitalo uses the following code in a comment on PR #673:

struct S {
    int P => 0; // not readonly
    
    int this[string s] => 0; // not readonly

    readonly void M() {
        _ = P; // warning CS8656: Call to non-readonly member 'S.P.get' from a 'readonly' member results in an implicit copy of 'this'.
        _ = this[""]; // warning CS8656: Call to non-readonly member 'S.this[string].get' from a 'readonly' member results in an implicit copy of 'this'.
        N(); // warning CS8656: Call to non-readonly member 'S.N()' from a 'readonly' member results in an implicit copy of 'this'.
    }

    void N() {}
}

@KalleOlaviNiemitalo is making a point about the warnings Roslyn issues, not about the three copies of this the Standard mandates as “defensive copies” as being redundant.

Surely a different compiler might choose to analyze P, this[] & N; figure out they do not modify the struct; skip the defensive copies; produce the intended semantics; and yet be non-compliant for doing so…

Are not defensive copies a compiler strategy for achieving a particular semantics; is the Standard mandating the strategy rather than the semantics; and in doing so limiting compilers (and performance in this case)?

Should not the strategy be left to the compilers, and the semantics to the Standard?

Or is it argued that the strategy here is the intended semantics?

[Ducking ;-)] Maybe someone should look into this…

[BillWagner]

I'd like to leave this in the backlog for our future selves. A good time is when we cover ref readonly parameter in C# 12.

It's a side trip at the moment, but I know the roslyn team has made some improvements so that defensive copies are made in fewer situations. I think more of these come in more recent versions, so what we have should be correct for 8.

[Nigel-Ecma]

While I’m not looking at getting into this anytime soon @BillWagner’s remark “the roslyn team has made some improvements so that defensive copies are made in fewer situations” does suggest this is a compiler strategy more than language semantics and maybe the closing remark should be “correct for roslyn C# 8”?

It is a bit of a gray area of course, but for example the Standard doesn’t even suggest, well enough require, how to handle await and that takes a fair bit of machinery (and MS has gone through a number of approaches in this case) compared to the simplicity of making a copy of something. Maybe we can get to this before C# 12…