Non-nullable value detected as nullable

[NiJeTi]

Version Used:
Version: 6.0.0
Commit: 4822e3c3aa

Steps to Reproduce:

object? GetPossibleNull1() => throw new NotImplementedException();
object? GetPossibleNull2() => throw new NotImplementedException();
void MethodAcceptingNotNull(object obj) => throw new NotImplementedException();

var object1 = GetPossibleNull1();
var object2 = GetPossibleNull2();

if (object1 is not null || object2 is not null)
    MethodAcceptingNotNull(object1 ?? object2);

Expected Behavior:
No warnings in build output

Actual Behavior:
Warning CS8604 : Possible null reference argument for parameter 'obj' in 'void MethodAcceptingNotNull(object obj)'.

[Youssef1313]

This is unfortunately by design. Similar issue: #36927

You can re-write the code as:

if (object1 is not null)
    MethodAcceptingNotNull(object1);
else if (object2 is not null)
    MethodAcceptingNotNull(object2);

or use null-forgiving operator !.

[jcouv]

Youssef is correct, this is by-design. Flow analysis keeps track of a state for each variable in the different branches of the code. When we get inside the if, the state is that both object1 and object2 are maybe-null.

[NiJeTi]

@jcouv As I understand, this happens because in my case both variables WAS NOT marked by flow analyzer as not-null. Am I right?

[Youssef1313]

@NiJeTi Kind of, but marking both as not-null is incorrect too. If both are marked not-null then:

if (object1 is not null || object2 is not null)
    MethodAcceptingNotNull(object1); // since both are not-null, this won't be an error while it should.

The request here, per my understanding, is a different type of flow analysis as stated in #36927 (comment).

[jcouv]

@NiJeTi Sorry if this is too much details. The analysis of || goes as follows: we compute two states after the first expression (whenTrue1 and whenFalse1). In whenTrue1 we'll have object1 as not-null, but in whenFalse1 we'll have object1 as maybe-null. Then we take the whenFalse1 case as starting point and analyze the second expression. This results in two states whenTrue2 where object2 is not-null and whenFalse2 where object2 is maybe-null. And in both those states, object1 is still maybe-null.
The state for the consequence block of the if is constructed by joining whenTrue1 and whenTrue2 (ie. taking the worse case from both states). That state has object1 and object2 as both maybe-null.

Because states just track whenever each local can be null, there is no way to represent "object2 is not-null when object1 is maybe-null".

[NiJeTi]

@jcouv thanks for the explanation. All works as I understood. I think issue can be closed for the moment. Thank you very much!