Should control flow statement also check for boolean assignment declared at is statement?

[Thaina]

Since the is expression can be use in if statement and also it can be apply to boolean variable like this

using System;

public class Program
{
	static bool _pending;
	static (string authCode, string redirectURL)? cache = ("123","xyz.com");
	public static void Main()
	{
		if(_pending = cache is (string authCode, string redirectURL))
		{
			Console.WriteLine(authCode);
		}

		if((cache is (string authCode2, string redirectURL2)) is bool pending)
		{
			Console.WriteLine(authCode2);
		}
	}
}

Currently now it error

Compilation error (line 11, col 22): Use of unassigned local variable 'authCode'
Compilation error (line 16, col 22): Use of unassigned local variable 'authCode2'

Should it also check for assignment if the boolean is field or variable?

[TahirAhmadov]

I guess it makes sense that this should work, but it's so easy to just add _pending = true; as a first statement in the then block, is it really worth fixing?

[Thaina]

1 is for else if chain
Another is, when we don't want to make bracket if, only one line if

if(_pending = cache is (string authCode, string redirectURL))
    Console.WriteLine(authCode);

[Joy-less]

I support this change. It would make all of the following possible:

using System;
					
public class Program
{
	public static void Main()
	{
		object o = "hello";
		bool b = false;
		
		// Exception: Use of unassigned local variable 's'
		{
			Console.WriteLine((b = o is string s) && s.Length == 0);
		}
		
		// Exception: Use of unassigned local variable 's'
		{
			Console.WriteLine((b = o is string s) ? s.Length == 0 : false);
		}
		
		// Exception: Use of unassigned local variable 's'
		{
			if ((b = o is string s) && s.Length == 0) {
				Console.WriteLine(true);
			}
		}
		
		// Exception: Use of unassigned local variable 's'
		{
			if (b = o is string s) {
				Console.WriteLine(s.Length == 0);
			}
		}
	}
}

In all of the above, if you remove the b = , it successfully compiles.

[Thaina]

Another use case

TimeSpan? expired = ObjectArray?[x]?.SomeLongProperty?.Expired;

if(expired == null || expired.Value > TimeSpan.Zero)
{
    neverExpiredIcon.SetActive(true);
    expiredHeader.SetActive(false);
}
else
{
    neverExpiredIcon.SetActive(false);
    expiredHeader.SetActive(true);
    expiredHeader.text = expired.Value.ToString(format);
}

can be

bool active = ObjectArray?[x]?.SomeLongProperty?.Expired is TimeSpan expired && expired > TimeSpan.Zero;
neverExpiredIcon.SetActive(!active);
expiredHeader.SetActive(active);
if(active && expired > TimeSpan.Zero) // if possible to capture the control flow state in variable for later used
    expiredHeader.text = expired.ToString(format);

[GeeLaw]

The second thing rightly should not compile, because

if ((cache is (string authCode2, string redirectURL2)) is bool pending)
{
  Console.WriteLine(authCode2);
}
// means
bool temp;
temp = (cache is (string authCode2, string redirectURL2));
if (temp is bool pending)
// ^^^ This condition is always true,
// because `temp` is of compile-time (hence runtime) type `bool`.
{
  // If temp == false, then authCode2 has not been assigned.
  Console.WriteLine(authCode2);
}

---

Regarding the first thing, it's not clear where the boundary is... What if you do

bool b;
object o;
if (b = !!(o is int i))
{
  // Should i be considered definitely assigned here?
  // What about b = MethodInThisAssembly(o is int i)?
  // Should compiler look into the code of MethodInThisAssembly?
  // Inter-procedural analysis is not done in C# compiler.
}

The current rule of C# is pretty "ignorant". Consider

object o = 1;
if ((o is int a) & (o is int b))
{
  // Neither a nor b is considered definitely assigned here.
}

The only way to satisfy definite assignment is to use only (), &&, ||, !, == true, == false, != true, != false in a condition involving subexpressions of E is T t, because they get translated to jumps instead of "normal" operations, so

object o = 1;

// &&
if ((o is int a) && (o is int b))
{
  // ...
}
// means
int a, b;
if (o is int)
{
  a = (int)o;
  if (o is int)
  {
    b = (int)o;
    {
      //...
      // Both a and b are considered definitely assigned here.
    }
  }
}

In contrast, =, &, | are translated to normal operations, so

object o = 1;

// &
if ((o is int a) & (o is int b))
{
  // ...
}
// means
int a, b;
bool fa, fb;
if (fa = (o is int)) a = (int)o;
if (fb = (o is int)) b = (int)o;
if (fa & fb)
{
  // ...
  // According to C# rules, neither a nor b is considered definitely assigned here.
}

[GeeLaw]

To be clear, it's entirely possible to refine the definite assignment analysis so that it handles =, & (built-in, for bool), | (built-in bool) in conditions, and that's not a huge change.

Still, there will be many unhandled cases, such as if ((o is int i).Equals(true)) { /* definite assignment of i? */ } etc.

[Thaina]

The second thing rightly should not compile, because

You are right it need to be

if ((cache is (string authCode2, string redirectURL2)) is bool pending && pending)
{
  Console.WriteLine(authCode2);
}

[Thaina]

Alternative design

If there could be just a keyword to check for the state of variable assignment it might be better. Expose the state of control flow statement directly

bool canExpired = ObjectArray?[x]?.SomeLongProperty?.Expired is TimeSpan expired;

neverExpiredIcon.SetActive(!canExpired);
expiredHeader.SetActive(canExpired);

if(expired is not null && expired > TimeSpan.Zero) // allow checking for variable assignment with is expression
    expiredHeader.text = expired.Value.ToString(format);

if(expired is set && expired > TimeSpan.Zero) // alternatively use set keyword
    expiredHeader.text = expired.Value.ToString(format);
if(expired is notnull && expired > TimeSpan.Zero) // alternatively use notnull keyword
    expiredHeader.text = expired.Value.ToString(format);
if(expired is scoped && expired > TimeSpan.Zero) // alternatively use scoped keyword
    expiredHeader.text = expired.Value.ToString(format);
if(required expired && expired > TimeSpan.Zero) // alternatively use required keyword
    expiredHeader.text = expired.Value.ToString(format);

[GeeLaw]

“variable is set” isn’t exposing control flow statements, but the definite assignedness per C# rules. This is a worse (and very bad) design than changing the definite assignment analysis rules. Once you expose “state of definite assignment analysis” to user code, you can never change the definite assignment analysis rules (to reduce false negatives) because that’ll change the meaning of existing programs (e.g., a new rule knows a variable is definitely assigned while the old rules didn’t, then any condition involving the definite assignedness of that variable will change to the other branch).

In contrast, if you change the definite assignment analysis rules, the only compatible change is to be less conservative so that it identifies more variables at more locations as definitely assigned. The only effect is more programs are allowed to compile, without changing its meaning. This is the better approach to take.