[Proposal]: Nullable ref

[hez2010]

Nullable ref

Motivation

We are consistently improving low-level struct experience and introduced ref field to the language to allow developers using ref safely in the language.

While it's possible to introduce yet another billion-dollars mistake that we are treating all refs to be not null despite a ref can be null in the code.

Thinking about the following code:

ref struct Foo<T>
{
    public ref T RefField;
}

This code will compile without a single line of warnings. If users use the code like this:

var foo = new Foo<int>();
Console.WriteLine(foo.RefField);

A NullReferenceException will be thrown at runtime. This has no difference than the world where we didn't have nullable reference type in the language.

As of today (April 25, 2024), a simple search on the GitHub showing that there're already some libraries start to use at least Unsafe.NullRef in the code:

As developers around the world upgrading their language version to the version that has ref fields, the adoption will increase.

To prevent such a potential billion-dollars mistake in the future, I propose to add nullable ref to the language.

Proposal

Nullable ref

We need to add nullable reference to the language. To do this, we can simply put a ? next to the ref keyword:

ref struct Foo<T>
{
    public ref? T RefField;
}

Now let's use the above type with following code:

var foo = new Foo<int>();
Console.WriteLine(foo.RefField); // warning: RefField may be null reference

As a sequence, a non-nullable ref type will require initialization, otherwise a warning will be produced:

ref struct Foo<T>
{
    public ref T RefField; // warning: RefField may be null reference
}

We may suppress the warning if all the non-default constructors assign a valid ref to the field:

ref struct Foo<T>
{
    public ref T RefField; // ok
    public Foo(ref T x) { RefField = ref x; }
}

To enforce the null safety, any default initobj to a struct containing non-nullable ref field will produce a warning:

var foo = default(Foo<int>); // warning: RefField is not initialized and may be null reference

ref struct Foo<T>
{
    public ref T RefField;
    public Foo(ref T x) { RefField = ref x; }
}

For generics allowing ref structs, a warning will be produced for any substitution of a ref struct containing non-nullable refs:

Test<Foo>(); // warning : RefField may be null reference if `default(T)` is used for initializing the object
void Test<T>() where T : allows ref struct { }
	
ref struct Foo
{
    public ref int RefField;
    public Foo(ref int x) { RefField = ref x; }
}

Keyword for null ref

To allow assigning a null reference to a nullable ref type, we can introduce a new keyword nullref to the language to be a safe alternative to Unsafe.NullRef<T>():

foo.RefField = nullref;

Why not null?

null is interpreted as an r-value, while nullref is a l-value, we want to distinguish them.

Alternative: use ref null for this:

foo.RefField = ref null;

Comparing with a ref with nullref

We can use ref x == nullref, ref x != nullref, and maybe ref x is nullref and ref x is not nullref as well, to check whether a ref is a null reference or not.

void Foo(ref? string strRef)
{
    if (
        ref strRef != nullref // check if the ref is valid
    ) { ... }
}

Or maybe simply use it without the ref, as the nullref already contains the semantic of ref:

void Foo(ref? string strRef)
{
    if (
        strRef != nullref // check if the ref is valid
    ) { ... }
}

Or with ref null:

void Foo(ref? string strRef)
{
    if (
        ref strRef != ref null // check if the ref is valid
    ) { ... }
    // or
    if (
        strRef != ref null // check if the ref is valid
    ) { ... }
}

Control-flow based nullable reference analysis

We need to introduce control-flow based nullable reference analysis for ref? as well, the rules can follow the same rules we have today for nullable reference types.

void Foo(ref? string strRef)
{
    Console.WriteLine(strRef); // warning: strRef may be null
    if (ref strRef != nullref)
    {
        Console.WriteLine(strRef); // ok
    }
}

We may want to mirror the nullable reference type code analysis related attributes as well:

• AllowNull: AllowNullRef
• DisallowNull: DisallowNullRef
• MaybeNull: MaybeNullRef
• NotNull: NotNullRef
• MaybeNullWhen: MaybeNullRefWhen
• NotNullWhen: NotNullRefWhen
• NotNullIfNotNull: NotNullRefIfNotNullRef
• MemberNotNull: MemberNotNullRef
• MemberNotNullWhen: MemberNotNullRefWhen

Open questions

• Should we make nullable ref related warnings errors? Given that the adoption of ref field is still not that wide, we may accept a small source breaking change here.

[huoyaoyuan]

See dotnet/roslyn#72165 and dotnet/roslyn#71487:

This is a bit of a gray area. C# as a language does not recognize that a ref can be null even though in reality it can be. It is very similar to the situation around bool where the language only recognizes true and false but there are effectively 254 other values of true that the language ignores. The code gen for the compiler does not attempt to take into account these other non-conforming values and this is just another case of that.

[HaloFour]

See: #497