[Proposal]: `Task<T>` nullability covariance

[jcouv]

Task<T> nullability covariance

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Task<T> nullability covariance (LDM tentatively approved, needs design proposal for task-like types)

It should be possible to return a Task<string!> for a Task<string?>.

using System.Threading.Tasks;
#nullable enable
public class C 
{
    public Task<(bool Result, string? Extras)> M() 
    {
        return Task.FromResult((true, "")); // currently produces a warning
    }
}

Motivation

See some examples of this problem: dotnet/roslyn#40759, dotnet/roslyn#40757

Unresolved questions

• needs design proposal for task-like types

Design meetings

Split issue from #3868
https://github.com/dotnet/csharplang/blob/main/meetings/2022/LDM-2022-09-28.md#nullability-improvements
https://github.com/dotnet/csharplang/blob/main/meetings/2024/LDM-2024-09-06.md#taskt-nullability-covariance

[szalapski]

Is there a general proposal for this?

That is, any operation that takes a Foo<T?> should be able to take a Foo<T>, since for reference types, T? is the same type as T. True?

If I supply a non-nullable object as a nullable parameter, it works just fine, but when I supply a generic of a nullable as a generic of a non-nullable, it gives me a warning. It isn't null forgiveness that I need, but the opposite--non-null forgiveness, which I thought should be implicit and not really a conscious thing that we would have to do.

[jnm2]

@szalapski I don't think that's true, for the same reason that any operation that takes a Foo<object> might not be able to take a Foo<string>. This is what in and out specify on generic parameters.

Let's say something expects a Foo<T?> because it wants to call Add(T?) and add null to it. Then it is not able to take a Foo<T> or else you end up with a null added to the Foo<T> and no warning about it in any location.

var list = new List<string>();
DoSomething(list); // This should, and does, cause a warning; you can't pass `List<string>` as `List<string?>`
Console.WriteLine(list[0].Length); // Or this happens

void DoSomething(List<string?> list) => list.Add(null);

[szalapski]

You are right.

Thinking it through, I intuitively expected that the Foo<T> would be implicitly cast to a Foo<T?> when the nullable version is accepted as a parameter. However, given that it doesn't and can't, how do I explicitly "cast" it? After all, T and T? are the same type, so casting doesn't make sense here.

[jnm2]

You use the nullability warning suppression operator, which is postfix !:

DoSomething(list!);

It's called the https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-forgiving operator, but I'm calling it the null-blindness operator and hoping it catches on. :D

[szalapski]

It isn't null forgiveness that I need, but the opposite--non-null forgiveness, which I thought should be implicit and not really a conscious thing that we would have to do.

[jnm2]

Nevertheless, the operator is a nullability warning suppression operator and is the way intended for you to suppress this particular nullability warning.