12.6.6.1: Defensive copy of input parameter

[KalleOlaviNiemitalo]

Describe the bug

In the C# 7.x draft, 12.6.6.1 (Function member invocation / General) describes how a copy of a value-type instance "not classified as a variable" is made and used instead of the original. This defensive copying should also apply to an input parameter unless its type is a readonly struct.

Example

using System;
struct S {
    public int I;
    public void M() { I++; }
}
readonly struct R {
    public void M() {}
}
class C {
    static void Main() {
        N(new S(), new S(), new R());
    }
    static void N(S s1, in S s2, in R r) {
        s1.M(); // no copying
        Console.WriteLine(s1.I); // 1
        
        s2.M(); // copy required
        Console.WriteLine(s2.I); // 0

        r.M(); // no copying
    }
}

Expected behavior

In 12.6.6.1, declare:

If E is not classified as a variable, or if E is an input parameter (15.6.2.3) and V is not a readonly struct type (16.2.2), then a temporary local variable of E’s type is created and the value of E is assigned to that variable.

Additional context

None.

---

Associated WorkItem - 157261

[KalleOlaviNiemitalo]

Need to verify the behaviour for enum types and for type parameters.

[KalleOlaviNiemitalo]

interface I {
    void M();
}
class C {
    void N<T>(T t1, in T t2)
    where T : struct, I {
        t1.M(); // no copying
        t2.M(); // defensive copy
    }
}

IL generated by Roslyn makes a copy even if where T : class, I; but in that case, it's a copy of the reference rather than of the instance itself, so has no observable effect in C#.

[KalleOlaviNiemitalo]

For a readonly struct, the lack of copying is observable by aliasing; although individual fields are readonly, the whole instance can be assigned.

using System;
readonly struct R {
    public readonly int I;
    public R(int i) {
        I = i;
    }
    public int M() {
        C.StaticR = new R(2);
        return I;
    }
}
class C {
    public static R StaticR = new R(1);
    static void Main() {
        N(in StaticR);
    }
    static void N(in R r) {
        Console.WriteLine(r.I); // 1
        int i = r.M(); // no copying (would copy if not readonly struct)
        Console.WriteLine(i); // 2 (would be 1 if not readonly struct)
        Console.WriteLine(r.I); // 2
    }
}

[KalleOlaviNiemitalo]

C# programs cannot define methods in enum types, and the methods of System.Enum do not mutate the instance, so defensive copying does not seem to be observable for enums.

Enum.ToString() could call a custom IFormatProvider, which could replace the enum instance to which this is aliased. However, that would probably happen after Enum.ToString() has already read the underlying value, and thus would not be able to prove that no defensive copy was made. Also, the System.IFormatProvider and System.Globalization.CultureInfo types are not required by Annex C and thus cannot be used by a strictly conforming program.

[KalleOlaviNiemitalo]

Need to check whether the special case for readonly struct should also apply when "E is not classified as a variable".

[Nigel-Ecma]

@KalleOlaviNiemitalo – Is the “defensive” copy you refer to the one specified in §12.6.2.3, bullet 1, sub-bullet 2?

[KalleOlaviNiemitalo]

@Nigel-Ecma, it is not the same.

[KalleOlaviNiemitalo]

In a method invocation r.M(a)

• 12.6.2.3 can require copying the value of a to a new place to which an input parameter of M will refer. I don't think that needs changing.
• 12.6.6.1 can require copying the value of r to a new place to which the this parameter of M will refer. This issue is about making that happen when r is an input parameter of the caller.

[Nigel-Ecma]

@KalleOlaviNiemitalo – OK, I see what you’re talking about now. Thanks.

[KalleOlaviNiemitalo]

The description of the example in 12.6.2.3 looks wrong though -- for the M1(i) call, the comment correctly says that "i is passed as an input argument" without a temporary, but then the text below claims that "In each method call, an unnamed int variable is created".

[KalleOlaviNiemitalo]

Ugh, the issue isn't even limited to input parameters. The wording needs to cover readonly fields, ref readonly returns, and ref readonly locals as well.

using System;
struct S {
    public void M() {}
}
class C {
    readonly S f = new S();
    S[] a = new S[1];
    
    void N() {
        f.M(); // copy
        
        ref readonly S r = ref a[0];
        r.M(); // copy
        
        ReadOnlySpan<S> ros = a;
        ros[0].M(); // copy
    }
}

IIUC, each of these is "classified as a variable".