Why are parameterless constructors not allowed on records?

Question

The following declaration:

type
  TRec = record
    constructor Create;
  end;

produces this compilation error:

E2394 Parameterless constructors not allowed on record types

The documentation rather unhelpfully states:

No further information is available for this error or warning.

My question is why the language was designed this way. Was it done this way purely to echo the analogous restriction for C# structs?

The language guide says this:

Records are constructed automatically, using a default no-argument constructor, but classes must be explicitly constructed. Because records have a default no-argument constructor, any user-defined record constructor must have one or more parameters.

But that doesn't make much sense. If there is a default constructor for a record, it can't be found through RTTI. And even if there was, why would that imply that it was impossible to add another one? You can do so for classes.

Perhaps the rationale is that if we were allowed to define our own parameterless constructors, we'd expect the compiler to call them automatically.

Note: I understand that you can use a parameterless static class function as a workaround. Indeed, I personally always prefer to use static class function instead of record constructors. But that's not the point of the question. What I really want to know is why parameterless constructors are not allowed on record types.

Answer 1

I can't give you a definitive answer (only the compiler builders can), but I suspect it is not related to Delphi's .NET past, but rather to Delphi's relation with C++Builder.

As cppreference says:

A default constructor is a constructor which can be called with no arguments (either defined with an empty parameter list, or with default arguments provided for every parameter).

C++ allows for parameterless constructors, and these parameterless constructors would become the default constructor, in C++. A default constructor is called in many situations, e.g. if you simply declare:

Foo myFoo;

The default constructor is called. This does not happen in Delphi, but a C++ programmer might expect it. Similarly, if you do:

Foo elements[1000];

The default constructor is called on each element (I checked that). This also doesn't happen in Delphi, although a C++ programmer might expect it.

Other hints that this is C++-related:

• Constructors with different names (e.g. Init) are not allowed either. This seems to point to conflicts with C++ or with C#, as in both, constructors have the name of the class or struct, so any parameterless constructor would be mapped to Foo() (in a struct or class called Foo.)
• Constructors with only default parameters are not allowed either. This matches the cppreference description for default constructors with only default arguments.

All in all, there are hints that parameterless constructors (or ones with only default parameters) conflict with C++ (i.e. C++Builder) and that that is why they are not allowed.

Note that this is not the only restriction caused by differences with C++: e.g. in Delphi you can't cast integers to and from floating point types either, because in C and C++, that would cause a conversion, while in Delphi, it would merely cause a reinterpretation of the bits. In order not to confuse people who were coming to Delphi from C or C++, the casting restriction was placed on floating point types. There may be more.