Error combining 'if' statements that null-checks and Pattern Matches

It would appear that this is not, in fact, a compiler error.

It was previously reported as a bug here.

However, it has been closed as not a bug. The reason is because of this part of the C# language spec (note: I am quoting here from user gafter on GitHub - this is NOT original content from myself):

If an operand of a conditional logical operator has the compile-time type dynamic, then the expression is dynamically bound (Dynamic binding). In this case the compile-time type of the expression is dynamic, and the resolution described below will take place at run-time using the run-time type of those operands that have the compile-time type dynamic.

Specifically, the && operation is not a compile-time boolean short-circuiting operation because its right-hand operand is of type dynamic.

Subtle stuff, and as DavidG says above, another reason to avoid dynamic where possible! (And I must confess, I'm still not completely convinced it's not a bug, but that's just me not understanding everything I guess...)

Ok, I was thinking for some time about this issue, and it looks that compiler behavior is pretty damn correct and it's not so hard to reproduce it even without dynamic values.

Some strange code will be required, nevertheless.

To start with we will overload && operator for our Foo type. It's not possible to overload short circuit logical operators directly, so we will overload true, false and & separately.

public static bool operator true(Foo x) => true;
public static bool operator false(Foo x) => true;
public static Foo operator &(Foo foo, Foo val) => new Foo();

Initially we had an expression foo != null && foo is Foo i in if block, now we want && from it to bound to our overload. For this reason we will overload != operator and == as well as they should be paired always.

public static Foo operator !=(Foo val, Foo val2) => new Foo();  
public static Foo operator ==(Foo val, Foo val2) => new Foo();

For now foo != null evaluates to Foo and foo is Foo evaluates to bool, but our && overload has signature (Foo, Foo) — still a mismatch, will add one more overload for implicit conversion from bool.

public static implicit operator Foo(bool val) => new Foo();

Here is the code for Foo type we've got so far

class Foo
{
    public static bool operator true(Foo x) => true;
    public static bool operator false(Foo x) => true;
    public static Foo operator &(Foo foo, Foo val) => new Foo();

    public static implicit operator Foo(bool val) => new Foo();

    public static Foo operator !=(Foo val, Foo val2) => new Foo();
    public static Foo operator ==(Foo val, Foo val2) => new Foo();
}

And voila! We have the same error for this piece.

 static void Main(string[] args)
 {
     Foo foo = GetFoo();

     if (foo != null && foo is Foo i)
     {
         // Use of unassigned local variable i
         // Local variable 'i' might not be initialized before accessing 
         Console.WriteLine(i);
     }
 }

 static Foo GetFoo() => new Foo();

And indeed, if we for example use foo is string i instead of foo is Foo i, i won't be initialized at runtime, but we will be inside if block.

Initial issue is rather equivalent, because of dynamic values involved. foo != null is dynamic, as far as foo is dynamic, so it means && should be bound at runtime, and we have no guarantees that i will be initialized.

Looks like Matthew quoted the same thing from github issue, but I personally wasn't able to grasp it from the beginning.