Is this a bug in record structs?

[dumptruckman]

I've stumbled upon something that seems like a bug with record structs. This proposal states:

If a record struct does not contain a primary constructor nor any instance constructors, and the record struct has field initializers, the compiler will synthesize a public parameterless instance constructor.

And then gives some examples. The one in question is

record struct R2(int F) { int F = F; } // no parameterless .ctor

However, you can still call new R2(); and the compiler does not complain.

Further, if this is in a nullable context, the result of this is that you can end up in a state where a non-nullable reference type is initialized as null.

You can fiddle around with an example of this here where I tried to hide the parameterless constructor to prevent using the automatically generated one. If you change that constructor to public then this compiles with a warning about converting a null literal to a non-nullable reference type. If you remove the extra constructor this will compile without warning which is definitely a problem since it hides the fact that you're getting a null value into a non-nullable reference type.

[HaloFour]

That example does have a primary constructor so the parameterless constructor is not synthesized.

However, in .NET, all value types have an implicit default value and C# has always allowed new R() which effectively means the same thing default(R2) if there is no parameterless constructor declared on the record.

[foxesknow]

This is by design. All structs get an implicit default constructor.

What's more crazy is that starting in C# 10 you'll be able to define an explicit default constructor, but still avoid calling it. For example:

struct Foo
{
    public Foo()
    {
        this.Count = 10;
    }
    
    public int Count{get;}
}

Foo x = new Foo();
Foo y = default;

Console.WriteLine(x.Count);  // Prints 10
Console.WriteLine(y.Count);  // Prints 0

It's a crazy "feature" that no doubt someone will suggest writing a code analyzer to handle...