Inconsistent "invalid list element constant" errors in analyzer

[srawlins]

See this example:

var b = 7;
var w = const A([b]);            // INVALID_CONSTANT
var x = const A([if (true) b]);  // INVALID_CONSTANT
var y = const A([if (false) b]); // NON_CONSTANT_LIST_ELEMENT
var z = const [b];               // NON_CONSTANT_LIST_ELEMENT

class A {
  const A(List<int> p);
}

This yields different errors for w, x, y, and z:

• w and x: INVALID_CONSTANT
• y and z: NON_CONSTANT_LIST_ELEMENT

I think it is particularly surprising that x and y have different errors. I think all of the errors should be NON_CONSTANT_LIST_ELEMENT. This inconsistency could represent just the in-progress improvements to errors-that-occur-in-const-instance-creation.

CC @kallentu

[lrhn]

I think the errors might be surprising, but not completel;y unexplainable.

The const [b] is invalid because b is not a constant expression. In particular, it's not a constant list element.
The const A([b]) is invalid because [b] is not a valid constant expression. It can be invalid for two reasons:

• Because [...] is intended to be constant, and b is not a valid constant list element, or
• Because [b] is not constant at all (it's a valid non-constant list expression where a constant expression is needed).

The latter is a little weird, because we'd assume that [b] in a const context will automatically be constant, but we also require it to be valid, and it isn't.
It does seems from the error that it's the latter that triggers the error.

For [if (true) b] and [if (false) b], an expression of the form [if (c) b] is a valid constant if c is true and b is a valid constant expression, or if c is false and b is a potentially constant expression (but possibly not valid constant expression).

Here b is neither. In the if (false) case, that makes if (false) b into an invalid constant expression in an element position.
In if (true), it the detected error is that b (which is used here) is not constant, but it's not used directly as a list element (well, it is, but not just).

Basically, there are multiple ways each example could be deemed invalid, and the error depends on which one happens to be detected first.

(Or maybe, as you say, some errors are just more up-to-date than the others, which will follow soon enough.)