Unnecessary defensive copy on `readonly struct` when performing a constrained call

[hamarb123]

Version Used: sharplab.io

Steps to Reproduce:

Here we go again with another unnessary defensive copy 😆

struct X
{
    private Y a;
    public readonly string W() => a.ToString(); //defensive copy for call to ToString
}

readonly struct Y
{
}

https://sharplab.io/#v2:EYLgtghglgdgNAFxFANgHwM4IE4FcDGCABABoCwAUAN6VF1EAO2UAbhAgKZECaREA3LXoABAMxFsHCABMA9jBQBPIsICMABiIB1ABQBKIgF4AfHwB0AFVkBlHLADm+wRQC+lSpJnylRLHkI8lDSulEA=

Diagnostic Id:

N/A

Expected Behavior:

No defensive copy is emitted for the call to .ToString(), since Y is readonly, and the default implementation provided by valuetype base classes also does not mutate (since they box & run on that, and also just don't mutate anyway, which is guaranteed by III.2.1) & any future overriding ToString implementation would have to be readonly since Y is readonly.

Actual Behavior:

A defensive copy of a is made (see below).

W marked readonly:

    .method public hidebysig 
        instance string W () cil managed 
    {
        .custom instance void [System.Runtime]System.Runtime.CompilerServices.IsReadOnlyAttribute::.ctor() = (
            01 00 00 00
        )
        .custom instance void [System.Runtime]System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
            01 00 01 00 00
        )
        // Method begins at RVA 0x2050
        // Code size 21 (0x15)
        .maxstack 1
        .locals init (
            [0] valuetype Y
        )

        IL_0000: ldarg.0
        IL_0001: ldfld valuetype Y X::a
        IL_0006: stloc.0
        IL_0007: ldloca.s 0
        IL_0009: constrained. Y
        IL_000f: callvirt instance string [System.Runtime]System.Object::ToString()
        IL_0014: ret
    } // end of method X::W

W not marked readonly:

    .method public hidebysig 
        instance string W () cil managed 
    {
        .custom instance void [System.Runtime]System.Runtime.CompilerServices.NullableContextAttribute::.ctor(uint8) = (
            01 00 01 00 00
        )
        // Method begins at RVA 0x2050
        // Code size 18 (0x12)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: ldflda valuetype Y X::a
        IL_0006: constrained. Y
        IL_000c: callvirt instance string [System.Runtime]System.Object::ToString()
        IL_0011: ret
    } // end of method X::W

[huoyaoyuan]

and the default implementation provided by valuetype base classes also does not mutate

Because they are not annotated as readonly?

Anyway, when you are calling the fallback implementation, defensive copy would be a smaller problem.

[hamarb123]

Because they are not annotated as readonly?

The method is not marked readonly, yes, but it is guaranteed to meet the requirements for readonly (due to the default implementation provided being guaranteed to not mutate the struct according to ECMA-335 III.2.1, and any future (or not exposed in ref assembly) implementations being required to be declared directly on the readonly struct & thus also having to meet the requirements for readonly); similarly to how methods not directly marked readonly declared on a readonly struct are also inferred to meet the requirements for readonly.

Anyway, when you are calling the fallback implementation, defensive copy would be a smaller problem.

Sure, but this is still a defensive copy that would ideally not be emitted as it's unnecessary. I don't doubt this will end up as help-wanted, but I might take a crack at all my open help-wanted defensive copies issues at some point in the future.

[tannergooding]

to not mutate the struct according to ECMA-335 III.2.1

For reference

When callvirt method instruction has been prefixed by constrained thisType the instruction is executed as follows.

• If thisType is a reference type (as opposed to a value type) then
  • ptr is dereferenced and passed as the ‘this’ pointer to the callvirt of method
• If thisType is a value type and thisType implements method then
  • ptr is passed unmodified as the ‘this’ pointer to a call of method implemented by thisType
• If thisType is a value type and thisType does not implement method then
  • ptr is dereferenced, boxed, and passed as the ‘this’ pointer to the callvirt of method

This last case can only occur when method was defined on System.Object, System.ValueType, or System.Enum and not overridden by thisType. In this last case, the boxing causes a copy of the original object to be made, however since all methods on System.Object, System.ValueType, and System.Enum do not modify the state of the object, this fact cannot be detected.