Different behavior of CFE and the analyzer when constant depends on itself

[sgrekhov]

The following code produces an error in the analyzer but no issues in VM.

const int? one = 2 > 1 ? null : one; // Analyzer error: The compile-time constant expression depends on itself

main() {
  print(one); // prints null
}

If to change the example to really invoke the constant then VM produces an error as well.

const int? two = 2 > 1 ? two: null; // Error: Constant evaluation error. Context: Constant expression depends on itself.

main() {
  print(two);
}

@eernstg @lrhn does in the first case the constant really depends on itself?

[dart-github-bot]

Summary: Analyzer detects self-referential constant one, but the VM doesn't, though a modified example (two) triggers VM error. Inconsistency needs investigation.

[mraleph]

cc @eernstg

[eernstg]

[Edit: The first version of this comment was not quite careful enough: It referred to #50383 which is about inference only, but the example in this issue does not rely on type inference. So I've basically rewritten this comment from scratch, reaching the opposite conclusion.]

The language specification says that

It is a compile-time error if the value of a constant expression depends on itself.

The null safety feature specification does not modify or add anything to this rule, nor does any other accepted feature specification as far as I can see.

It is not possible to refer to the value of a constant expression (or any expression) directly, it only occurs when that expression is the initializing expression in a constant variable declaration (or some subexpression thereof), such that we can refer to the value (or to some object that indirectly provides access to the value of that subexpression). This means that the above rule must give rise to an error at or in the same declarations as the following rule:

'It is a compile-time error if the value of a constant variable depends on the value of that same constant variable.'

This means that it is not sufficient to have a syntactic cycle (in the example: The declaration of the variable one contains a reference to one). Instead, it is required that the evaluation of the value can only be completed if that same value can be obtained during this evaluation.

This is not true when it comes to the example in this issue, because the value of one is not needed in order to evaluate 2 > 1 ? null : one.

This means that no error should be reported, and the analyzer should be adjusted accordingly.