Implement constant equality as primitive equality

[eernstg]

Cf. dart-lang/language#1811.

'Having a primitive operator ==' has now been generalized to 'having primitive equality', cf. #51045. The implementation of this feature is ongoing as of Feb 2023 (and I think it has been completed in the analyzer).

As a further regularization of the treatment of equality in constant expressions, this issue is concerned with the implementation of constant equality as primitive equality.

In particular here is the current specification of constant expressions of the form e1 == e2:

An expression of the form \code{$e_1$\,==\,$e_2$} is potentially constant
if $e_1$ and $e_2$ are both potentially constant expressions.
It is further constant if both $e_1$ and $e_2$ are constant and
either $e_1$ evaluates to an object that is an instance of
\code{int}, \code{double}, \code{String}, \code{bool} or \code{Null},
or if $e_2$ evaluates to the null object (\ref{null}).

It will be modified to rely on primitive equality instead, approximately:

An expression of the form \code{$e_1$\,==\,$e_2$} is potentially constant
if $e_1$ and $e_2$ are both potentially constant expressions.
It is further constant if both $e_1$ and $e_2$ are constant, and
$e_1$ has a primitive equality
(\ref{theOperatorEqualsEquals}),
or $e_2$ evaluates to the null object (\ref{null}).

[Edit: To avoid a breaking change, the spec update will continue to admit double even though double does not have primitive equality; cf. dart-lang/language#2874.]

Note that this change implies that enum values can be used as operands to == in a constant expression, cf. dart-lang/language#312. This is a consequence of the fact that no enum declaration can declare or inherit an implementation of operator == or hashCode that overrides the declaration in Object.

---

Subtasks:

• [specification] Implement constant equality as primitive equality language#2873
• [analyzer] Implement constant equality as primitive equality #51567
• [cfe] Implement constant equality as primitive equality #51566

[scheglov]

double does not have primitive equality, right?
So, now const v = 1.2 == 2.3; is an error?

[eernstg]

Right, double does not have primitive equality and 1.2 == 2.3 is not a constant expression.

[scheglov]

And 1.2 == 2.3 is not a constant expression only when patterns are enabled?

[eernstg]

Oops, that's an unintended breaking change. We'll fix the spec update to avoid the breaking change in dart-lang/language#2874. Thanks for the heads up!

[eernstg]

dart-lang/language#2874 has now landed, and the ability to have a double as the left operand of a constant == expression has been preserved as a special exception.

[bernaferrari]

Out of curiosity, would "fixing" it be "that breaking"? For example, would any test fail? It seems small enough that could be fixed.

[eernstg]

I'm not entirely sure what that means. If we change the rules such that someConstantVariableOfTypeDouble == 1.5 is suddenly not a constant expression then we might break any number of programs without helping anyone. OK, it's probably only very, very few cases, but it might still break a much larger number of lines of code, because any such expression could occur in a widely used library.

double was never considered to have primitive equality (previously known as "having a primitive operator ==") because equality for double is weird: double.nan != double.nan. So we'd have non-standard behaviors in collections where double.nan is used. E.g., const <double, String>{double.nan: "Not a number"} would return null when we try to look up double.nan.

So we did not want to give double primitive equality, and we did not want to break programs for basically no reason, and that's the reason why we did what we did.

In summary, I'm not 100% sure what 'fixing it' would mean. 😄