Records: no error on absence of the parameter-less object constructor call by the copy constructor

[pkulikov]

(Don't know if that's the compiler or spec issue.)

The current spec proposal about the record copy constructor says the following (emphasis is mine):

An explicitly declared copy constructor must be either public or protected, unless the record is sealed. The first thing the constructor must do, is to call a copy constructor of the base, or a parameter-less object constructor if the record inherits from object. An error is reported if a user-defined copy constructor uses an implicit or explicit constructor initializer that doesn't fulfill this requirement.

From that, I would expect the following code (sharplab) to generate the CS8868 error (see the error example further below):

public record Number
{
    public int N { get; set; }
    protected Number(Number original) => N = original.N;
}

It doesn't. Also, if I remove the user-defined copy constructor, the auto-generated one doesn't contain the : base() call as well:

protected Number(Number original)
{
    <N>k__BackingField = original.<N>k__BackingField;
}

With record inheritance:

public record Empty;
public record Number : Empty
{
    public int N { get; set; }
    protected Number(Number original) => N = original.N;
}

the following error is generated:

error CS8868: A copy constructor in a record must call a copy constructor of the base, or a parameterless object constructor if the record inherits from object.

So, when is it really necessary to call a parameter-less object constructor?
And if itsn't necessary, why is it mentioned in the error message and the spec proposal, then?

[svick]

I think the spec is meant to allow calling base() in this case implicitly, which is what happens both with your hand-written and auto-generated copy constructors. One way to see that is to look at the generated IL. For the hand-written constructor, it's:

    .method family hidebysig specialname rtspecialname 
        instance void .ctor (
            class Number original
        ) cil managed 
    {
        // Method begins at RVA 0x20ab
        // Code size 19 (0x13)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [System.Private.CoreLib]System.Object::.ctor()
        IL_0006: ldarg.0
        IL_0007: ldarg.1
        IL_0008: callvirt instance int32 Number::get_N()
        IL_000d: call instance void Number::set_N(int32)
        IL_0012: ret
    } // end of method Number::.ctor

For the auto-generated one, it's:

    .method family hidebysig specialname rtspecialname 
        instance void .ctor (
            class Number original
        ) cil managed 
    {
        // Method begins at RVA 0x21d0
        // Code size 19 (0x13)
        .maxstack 8

        IL_0000: ldarg.0
        IL_0001: call instance void [System.Private.CoreLib]System.Object::.ctor()
        IL_0006: ldarg.0
        IL_0007: ldarg.1
        IL_0008: ldfld int32 Number::'<N>k__BackingField'
        IL_000d: stfld int32 Number::'<N>k__BackingField'
        IL_0012: ret
    } // end of method Number::.ctor

Notice that in both cases, the object constructor is called.

I think that part of the spec is meant to forbid code like the following:

public record Number
{
    public int N { get; set; }
    protected Number(Number original) : this() => N = original.N;
    public Number() {}
}

Which does produce an error message that mirrors the spec:

error CS8868: A copy constructor in a record must call a copy constructor of the base, or a parameterless object constructor if the record inherits from object.

[pkulikov]

Thank you @svick. So, the parameter-less object constructor call is automatically added by the compiler to follow the spec. That leaves the error message a bit misleading to a developer, because for your example of the erroneous code the following message would be clearer:

A copy constructor in a record must call a copy constructor of the base, or, if the record inherits from object, can call only a parameterless object constructor.

The current error message suggests the following solution:

public record Number
{
    public int N { get; set; }
    protected Number(Number original) : base() => N = original.N;
    public Number() {}
}

which is fine, but not necessary.
However, I think I'm nit-picking here. Again, thank you for the clarification, @svick