Flow analysis. Second operand of for(;;) loop issue

[sgrekhov]

The following code works wihout issues in both CFE and the analyzer.

void test(Never n) {
  late int i;
  for (;n;) {
    i = 42; // No dead code warning here
  }
  i; // No error here
}

But i = 42 is dead code; there is no way to avoid executing the second operand of the for(;;) loop. Flow analysis should detect this, and i; should produce an error because i is definitely unassigned here.

Dart SDK version: 3.8.0-66.0.dev (dev) (Sun Feb 2 20:05:47 2025 -0800) on "windows_x64"

[dart-github-bot]

Summary: Dead code warning missing in for loop. Flow analysis fails to detect that i remains unassigned within the loop's unreachable body.

[lrhn]

The i is also dead code, so not getting an "unassigned" eror seems fine, if dead code is detected at all.

It's tricky to type-analyze dead code, because there is no flow of control into it, so no type inference input.

And, arguably, the entire function body is dead code. There is no possible way to call the function with any argument.
If a variable in the current scope has type Never, all code after that variable's introduction is dead.

[sgrekhov]

The i is also dead code, so not getting an "unassigned" eror seems fine, if dead code is detected at all.

Yes. Let's rewrite the example so that i is not dead code.

void test(Never n) {
  late int i;
  if ((() => false)()) {
    for (; n;) {
      i = 42; // No dead code warning here
    }
  }
  i; // Definitely unassigned and not a dead code but no error
}

[sgrekhov]

I believe this is the same issue.

test1() {
  late int i;
  for (;false; i = 42) {}
  i; // Definitely unassigned but no error in CFE and the anallyzer 
}

[lrhn]

Might be the same issue, might not.
There is a big difference between an expression being false and it being Never.
In the former case the loop may chose to not enter its body. It's loop semantics whether it does or not, and constant propagation whether flow control knows that the value of always false.
In the latter case, the loop never runs, independently of whatever semantics it might have.