Allowing sealed classes as generic constraints to help annotate nullability relationships

[safakgur]

In the following example, there is no way to annotate the nullability of the returning Foo's generic argument to be the same as the nullability of the accepted Foo's generic argument.

Foo<string?> Bar(Foo<string?> foo)
{
    if (foo.Value is null) { /* Something */ }
    else { /* Some other thing that uses the string API */ }
    return foo;
}

var f = new Foo<string>("s");
var r = Bar(f); // Warns because f's type parameter is not nullable

A signature like Foo<T> Bar(Foo<T> foo) would allow us to preserve the nullability and adding a type constraint like where T : SomeClass? would allow us to use type-specific functionality in the method. But sealed classes like string can't be used as type constraints.

I understand it didn't make sense before but I think it may be useful to lift this restriction (it is already allowed in IL) now with nullable reference types in the wild, so we can do:

Foo<T> Bar<T>(Foo<T> foo)
    where T : string?
{
    if (foo.Value is null) { /* Something */ }
    else { /* Some other thing that uses the string API */ }
    return foo;
}

var f1 = new Foo<string>("s");
var r1 = Bar(f1); // Foo<string>

var f2 = new Foo<string?>("s");
var r2 = Bar(f2); // Foo<string?>

I also asked about this on Stack Overflow.

[YairHalberstadt]

It's definitely an interesting problem, and the suggested solution does have a lot going for it.

However I'm not sure this would work in most cases. For example:

Foo<T> Bar<T>(Foo<T> foo)
    where T : string?
{
    if (foo.Value is null) { return new Foo<T?>(null); }
    else { return new Foo<T>(foo.Value.Substring(1,2)); }
}

This will fail to compile, since the return type of string.Substring is string, not T.

[huoyaoyuan]

I think this will get help if NotNullWhenNotNull get extended.