CFE accepts records with non-primitive equality as elements of const sets

[chloestefantsova]

UPDATE: As mentioned by @eernstg in the comment below, the non-trivial equality of objects should affect the constant sets with such objects, not the ability of the objects to be constant. The original contents of the issue is left at the bottom, for archival purposes.

The following program is compiled by the CFE without any compile-time error.

class A {
  const A();

  bool operator==(Object other) => false;
}

test() => const <(A,)>{ (A(),) };

A compile-time error is expected because A declares a non-trivial equality, and records containing such objects can't be elements of constant sets.

The analyzer displays the following error message for that program.

error - asdf.dart:7:25 - The type of an element in a constant set can't override the '==' operator, but the type '(A)' does. Try using a different value for the element, or removing the keyword 'const' from the set. - const_set_element_type_implements_equals

THE ORIGINAL ISSUE CONTENTS:

The following code is accepted by the CFE, but a compile-time error is expected. Note that const A() is accepted even outside of record literals.

class A {
  const A();

  bool operator==(Object other) => false;
}

test() => const (A(), A());

test2() => const A();

The Kernel output is the following:

library /*isNonNullableByDefault*/;
import self as self;
import "dart:core" as core;

class A extends core::Object /*hasConstConstructor*/  {
  const constructor •() → self::A
    : super core::Object::•()
    ;
  operator ==(core::Object other) → core::bool
    return false;
}
static method test() → dynamic
  return #C2;
static method test2() → dynamic
  return #C1;
constants  {
  #C1 = self::A {}
  #C2 = (#C1, #C1)
}

[eernstg]

This is not a problem. A class can have a constant constructor and be used in constant expressions, and still have an operator == that runs any code it wants. However, there should be an error if const A() is used in a situation where it is required to have a primitive operator ==, like const s = {A()};. I do get that error from both the CFE and the analyzer. I think it's fine!

[chloestefantsova]

This is not a problem. A class can have a constant constructor and be used in constant expressions, and still have an operator == that runs any code it wants. However, there should be an error if const A() is used in a situation where it is required to have a primitive operator ==, like const s = {A()};. I do get that error from both the CFE and the analyzer. I think it's fine!

Thanks for the clarification, Erik! I updated the text of the issue accordingly.