Different reference types: nullable and non-nullable

[BillWagner]

Fixes #1089
Fixes #1090

This is an alternative to #1105

The changes were done on top of the branch for #1105. The final commit has the updates to remove null oblivious types.

It removes the text for a "null-oblivious" type. Instead, it relies on the nullable context for how to interpret the nullability of a reference type T.

[jskeet]

More comments, but I think we're making progress :)

[BillWagner]

Comments on updates per feedback.

[jskeet]

Getting there :) Sorry to keep picking nits, but I'm definitely keen on getting this one over the line rather than the alternative that has null-oblivious.

[Nigel-Ecma]

I think I like this approach better than #1105, but do see some issues.

[Nigel-Ecma]

A few language changes, some comments to consider.

As with #1123 I am recommending we don’t merge this, we get it to a state we’re currently happy with, move on to others in the group, circle back around as needed, and then merge/reject the group as a whole.

[gafter]

We may need three types, not two. For example:

void f(
#nullable disable
string x, // could x (oblivious) be seen as nullable type but non-nullable initial state?
#nullable enable
string y,
string? z)
{
 if (...) {
   // x state is not null? or oblivious?
   g1(ref x); // okay
   g1(ref y); // not okay
   g1(ref z); // okay
   // x state is possibly null
 } else {
   // x state is not null? or oblivious?
   g2(ref x); // okay
   g2(ref y); // okay
   g2(ref z); // not okay
   // x state is possibly null
 }
}
void g1(ref string? x) {}
void g2(ref string x) {}

[BillWagner]

Very short version:

f("x", "y", "z");
void f(
#nullable disable
    string x,
#nullable enable
    string y,
    string? z)
{
    y = x; // no warning
    y = z; // warning. Assignment of null to non-nullable variable.
}

[jskeet]

Example of why I believe it makes sense to view a variable of type T declared in a nullable-disabled context as a nullable type:

# nullable disable
string x;
# nullable enable
x = "some value";
x = null;

This does not issue a warning, even for the last line. The state of x just before the last line is surely "definitely not null" as we've assigned a string literal to it... so to be able to assign null to it means its type can't be a not-null type.

[BillWagner]

#nullable enable
string s = M();

#nullable disable
// What is the type of the return value?
string M() => null;

[RexJaeschke]

Note that from 2024-8-20 through 2024-09-03, there was a lengthy thread on email re this topic, under the subject "ECMA TC49-TG2 agenda for September 4th."

[BillWagner]

comments during our meeting

[jskeet]

Thanks! Big step forward :)

[BillWagner]

I've addressed all open comments, and resolved all conversations. This is ready for a final (asynchronous) pass and approval.

@jskeet @Nigel-Ecma @MadsTorgersen @ericlippert @RexJaeschke @gafter

[Nigel-Ecma]

Just a missing word and a one word change suggestion.

Change made