Add Type Constraint for Parameterless Constructor that allows required Members

[AeonSake]

There is currently no way to use the constraint of a parameterless constructor on a type that also has required members. This can be especially annoying for factory methods or lambda builders.

Example:

public abstract class A
{
    public required int Prop { get; init; }
}

public class B : A;

//...

public T CreateInstance<T>(int value) where T : A, new()
{
    return new T {Prop = value}; //this is fine
}

//...

var b = CreateInstance<B>(10); //throws CS9040

Even though the requirements of the base class A have been satisfied (all required members are set), the call to the method itself fails because the use of B is not allowed in this context because it has required members.

It would be great to have a constraint for this scenario as I feel like this is missing from the introduction of the required modifier. A specification proposal could look like this (following the recent addition of allows ref struct):

public T CreateInstance<T>(int value) where T : A, allows required new()
{
    return new T {Prop = value};
}

The compiler in this case would need to verify that all required members of the constrained type have been satisfied and that inherited types don't add additional required members.

[TahirAhmadov]

What if you have:

public class B : A
{
  public required string OtherProp { get; init; }
}
var b = CreateInstance<B>(10); // no CS9040
Assert.AreEqual(null, b.OtherProp); // OOPSIES!!!

[AeonSake]

The compiler in this case would need to verify that all required members of the constrained type have been satisfied and that inherited types don't add additional required members.

That's why I added this at the end of my proposal. The Compiler in this case would prevent the use of B as a generic type (just as it already does right now).

[AeonSake]

Thinking about this a bit more, I don't think a new modifier/keyword is even needed here. This can work if the compiler ensures that class B fully satisfies the new() creation criteria on the called type constraint where T : A, new(), that is that B (and any other derived type) doesn't include additional required members. No further changes needed. Existing code can also be used with the now relaxed creation constraints without change or breaking anything.