What is the benefit of erroring rather than inferring the class constraint on overridden methods?

[jnm2]

The compiler infers where T : class on the override when T? does not appear in the signature:

abstract class Base
{
    public abstract T M<T>() where T : class;
}

class Derived : Base
{
    public override T M<T>()
    {
        throw new NotImplementedException();
    }
}

When T? does appear in the signature, what is the benefit of where T : class not being inferred?

abstract class Base
{
    public abstract T? M<T>() where T : class;
}

class Derived : Base
{
    // ❌ CS0508 'Derived.M<T>()': return type must be 'T' to match overridden member
    // ❌ CS0453 The type 'T' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable<T>'
    //                 ↓
    public override T? M<T>()
    {
        throw new NotImplementedException();
    }
}

Also, where T : struct is inferred, which was required for backwards compatibility with C# 7:

abstract class Base
{
    public abstract T? M<T>() where T : struct;
}

class Derived : Base
{
    public override T? M<T>()
    {
        throw new NotImplementedException();
    }
}

This means that adding a base where T : class overload is a source-breaking change. In the opposite scenario, I would expect adding a base where T : struct overload to also be a breaking change. So requiring explicit where T : class on the derived class to avoid this breaking change doesn't seem like a good explanation for why where T : class would not be inferred. @svick corrected this in an answer. Thanks!

I'm not finding the answer to this question in https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-06-17.md#t.

[RikkiGibson]

@cston may know the answer to this.

[svick]

I think the problem is code like the following:

#nullable enable

abstract class Base
{
    public virtual void M<T>(T? x) where T : struct {}
    public virtual void M<T>(T? x) where T : class {}
}

class Derived : Base
{
    public override void M<T>(T? x) {}
}

In Derived, T? is understood as Nullable<T>, so where T : struct is inferred. That also means adding the where T : class overload to the class after the where T : struct overload is not a source breaking change.

But if it was possible to infer where T : class, as you suggest, then adding the where T : struct overload would be a source breaking change.