Auto-assign null or Implicitly Consider nullable references to have null values

[kumarc-ps]

With recent versions of C# we generally use null-able local and global declarations of several references.

The compiler is currently taking the unassigned declarations of null-able references as error statements. Because we are already declaring the reference as null-able explicitly, I expect the compiler or the runtime to implicitly assign the null value or consider it as a null value reference.

Declaring a reference as null-able and assigning a null value adds redundant meaning to the declaration. As explicitly declared null-able references are preferred, it's better to have the null assignment removed (as developer's task).

Overall, if a null-able reference declaration is present, then it should either have an implicitly assigned null value or the runtime needs to consider the reference to have null value, rather than the developer explicitly assigning a null value.

Code Example (Current version): This triggers a compiler error - Use of unassigned local variable 'innerException

public static RestException CreateException(Uri requestUri, IRestResponse response)
{
    Exception? innerException;
    // Exception? innerException = null; // Doesn't throw any compiler error
    var messageBuilder = new StringBuilder();
    // do something

    return new RestException(response.StatusCode, requestUri, response.Content, messageBuilder.ToString(), innerException);
 }

It would be good to consider the above declaration as a valid statement.

Adding below statement to not to get confused for methods/functions.
If a method/function has any null-able parameter(s), then it doesn't mean that the caller can skip the parameter unless it's default value is declared.

[YairHalberstadt]

The purpose of the error is to make sure that you assign the variable in all code paths. This is particularly helpful when you set a variable separately in both branches of an if/else statement, or in all branches of a switch statement. It's easy to make a mistake and forget to assign it in one branch. Note this has nothing to do with nullability - you might explicitly set it to null in one of the branches, but it's still important you handle it in all branches and decide explicitly what value you want it to be.

Removing this error would make some cases slightly shorter (but less explicit), but make a certain class of errors more likely. It's not obvious this is a net positive tradeoff.

[kumarc-ps]

I agree with Yair's comment.
What you can do is using the default keyword:

Exception? innerException = default;

With this code you can force an initialization and it is less redundant...

Got another point from your feedback. This should be avoided mostly (in recent versions of C# that have null check enabled), as null-able references take over normal declarations, because null-able references are more clear and concise.

The declarations of normal and null-able declarations should be made mutually exclusive. That is any normal (non-null) declaration should never have null value. This should treated as a non-null reference at all times.

[kumarc-ps]

At the moment there's ambiguity in reference declaration in C#. A declaration without nullable marker (the ? symbol next to the type of declaration), is now allowed to have both null and non-null assignments. Assignments to such declarations need to be checked correctly. I mean, if the assignment is a null value resulting in evaluating an expression or a value returned from a method/function, the compiler should throw an error clearly saying "Cannot convert null to expected type" or "Cannot assign null to a non-null reference"

[bernd5]

See the following code snippet:

using System;

#nullable enable

string value; //here value has "indetermined value" - it is not null / no warning!

//would cause an error
//Console.WriteLine(value);

bool x = true;
if (x){
    value = "AAA";
} else{
    value = "BBB";
}

//both branches ensure that value is assigned
Console.WriteLine(value);

Here no assignment / value is required at string value. It just declared there to be accessed later.

[kumarc-ps]

I was referring to the declaration below and your code is 100% correct. From your code, the compiler should assume that the value is not-null and if the value seems to have not been assigned in any branch, it must be treated as an error.

Here the value is declared as a null-able reference.

public string? GetSomeString(bool x)
{
    string? value;
    if (x){
        value = "AAA";
    }
    return value;
}

Here the declaration of value is assigned only if x is true. The value is expected to have null value without even assigning it, because I have declared as null-able. In my opinion the compiler should not throw any error for not assigning a value or not having an else part. It is the developer's choice pf returning a null value. And this null should be returned even without explicitly assigning value = null;.

[HaloFour]

You're mixing up nullability and definite assignment. The compiler wants the developer to be explicit about any values assigned to the variable before it is used. This behavior is very intentional as it avoids a common form of bug that will occur if you then accidentally miss an assignment in one of the conditional branches. You can already silence the compiler by assigning a default value on the initial declaration, but I would submit that this is a bad idea as you then lose the definite assignment check which will result in errors at runtime. The compiler should definitely never implicitly assign a value here.