[cfe] Implement primitive equality

Closes #51045
Closes #51565
Closes #51566
Closes #51688
Closes #51800

Change-Id: I4a679ef9cf496a22f4fdc2047a2dc4753e796e2b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/290320
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>

Author: johnniwinther

pkg/front_end/lib/src/fasta/fasta_codes_cfe_generated.dart

@@ -467,6 +467,72 @@ Message _withArgumentsConstEvalElementImplementsEqual(
       arguments: {'constant': _constant});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+        Message Function(Constant _constant, bool isNonNullableByDefault)>
+    templateConstEvalElementNotPrimitiveEquality = const Template<
+            Message Function(Constant _constant, bool isNonNullableByDefault)>(
+        problemMessageTemplate:
+            r"""The element '#constant' does not have a primitive equality.""",
+        withArguments: _withArgumentsConstEvalElementNotPrimitiveEquality);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(Constant _constant, bool isNonNullableByDefault)>
+    codeConstEvalElementNotPrimitiveEquality = const Code<
+        Message Function(Constant _constant, bool isNonNullableByDefault)>(
+  "ConstEvalElementNotPrimitiveEquality",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsConstEvalElementNotPrimitiveEquality(
+    Constant _constant, bool isNonNullableByDefault) {
+  TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+  List<Object> constantParts = labeler.labelConstant(_constant);
+  String constant = constantParts.join();
+  return new Message(codeConstEvalElementNotPrimitiveEquality,
+      problemMessage:
+          """The element '${constant}' does not have a primitive equality.""" +
+              labeler.originMessages,
+      arguments: {'constant': _constant});
+}
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+        Message Function(
+            Constant _constant, DartType _type, bool isNonNullableByDefault)>
+    templateConstEvalEqualsOperandNotPrimitiveEquality = const Template<
+            Message Function(Constant _constant, DartType _type,
+                bool isNonNullableByDefault)>(
+        problemMessageTemplate:
+            r"""Binary operator '==' requires receiver constant '#constant' of a type with primitive equality or type 'double', but was of type '#type'.""",
+        withArguments:
+            _withArgumentsConstEvalEqualsOperandNotPrimitiveEquality);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<
+        Message Function(
+            Constant _constant, DartType _type, bool isNonNullableByDefault)>
+    codeConstEvalEqualsOperandNotPrimitiveEquality = const Code<
+        Message Function(
+            Constant _constant, DartType _type, bool isNonNullableByDefault)>(
+  "ConstEvalEqualsOperandNotPrimitiveEquality",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsConstEvalEqualsOperandNotPrimitiveEquality(
+    Constant _constant, DartType _type, bool isNonNullableByDefault) {
+  TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+  List<Object> constantParts = labeler.labelConstant(_constant);
+  List<Object> typeParts = labeler.labelType(_type);
+  String constant = constantParts.join();
+  String type = typeParts.join();
+  return new Message(codeConstEvalEqualsOperandNotPrimitiveEquality,
+      problemMessage:
+          """Binary operator '==' requires receiver constant '${constant}' of a type with primitive equality or type 'double', but was of type '${type}'.""" +
+              labeler.originMessages,
+      arguments: {'constant': _constant, 'type': _type});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<Message Function(DartType _type, bool isNonNullableByDefault)>
     templateConstEvalFreeTypeParameter = const Template<
@@ -865,6 +931,35 @@ Message _withArgumentsConstEvalKeyImplementsEqual(
       arguments: {'constant': _constant});
 }
 
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Template<
+        Message Function(Constant _constant, bool isNonNullableByDefault)>
+    templateConstEvalKeyNotPrimitiveEquality = const Template<
+            Message Function(Constant _constant, bool isNonNullableByDefault)>(
+        problemMessageTemplate:
+            r"""The key '#constant' does not have a primitive equality.""",
+        withArguments: _withArgumentsConstEvalKeyNotPrimitiveEquality);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+const Code<Message Function(Constant _constant, bool isNonNullableByDefault)>
+    codeConstEvalKeyNotPrimitiveEquality = const Code<
+        Message Function(Constant _constant, bool isNonNullableByDefault)>(
+  "ConstEvalKeyNotPrimitiveEquality",
+);
+
+// DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
+Message _withArgumentsConstEvalKeyNotPrimitiveEquality(
+    Constant _constant, bool isNonNullableByDefault) {
+  TypeLabeler labeler = new TypeLabeler(isNonNullableByDefault);
+  List<Object> constantParts = labeler.labelConstant(_constant);
+  String constant = constantParts.join();
+  return new Message(codeConstEvalKeyNotPrimitiveEquality,
+      problemMessage:
+          """The key '${constant}' does not have a primitive equality.""" +
+              labeler.originMessages,
+      arguments: {'constant': _constant});
+}
+
 // DO NOT EDIT. THIS FILE IS GENERATED. SEE TOP OF FILE.
 const Template<
         Message Function(Constant _constant, bool isNonNullableByDefault)>

pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart

@@ -159,10 +159,17 @@ class SetConstantBuilder extends _ListOrSetConstantBuilder<SetLiteral> {
   @override
   AbortConstant? addConstant(Constant constant, TreeNode context) {
     if (!evaluator.hasPrimitiveEqual(constant)) {
-      return evaluator.createEvaluationErrorConstant(
-          context,
-          templateConstEvalElementImplementsEqual.withArguments(
-              constant, evaluator.isNonNullableByDefault));
+      if (evaluator.enablePrimitiveEquality) {
+        return evaluator.createEvaluationErrorConstant(
+            context,
+            templateConstEvalElementNotPrimitiveEquality.withArguments(
+                constant, evaluator.isNonNullableByDefault));
+      } else {
+        return evaluator.createEvaluationErrorConstant(
+            context,
+            templateConstEvalElementImplementsEqual.withArguments(
+                constant, evaluator.isNonNullableByDefault));
+      }
     }
     bool unseen = seen.add(constant);
     if (!unseen) {
@@ -304,10 +311,17 @@ class MapConstantBuilder {
       parts.add(lastPart = <ConstantMapEntry>[]);
     }
     if (!evaluator.hasPrimitiveEqual(key)) {
-      return evaluator.createEvaluationErrorConstant(
-          keyContext,
-          templateConstEvalKeyImplementsEqual.withArguments(
-              key, evaluator.isNonNullableByDefault));
+      if (evaluator.enablePrimitiveEquality) {
+        return evaluator.createEvaluationErrorConstant(
+            keyContext,
+            templateConstEvalKeyNotPrimitiveEquality.withArguments(
+                key, evaluator.isNonNullableByDefault));
+      } else {
+        return evaluator.createEvaluationErrorConstant(
+            keyContext,
+            templateConstEvalKeyImplementsEqual.withArguments(
+                key, evaluator.isNonNullableByDefault));
+      }
     }
     bool unseenKey = seenKeys.add(key);
     if (!unseenKey) {

pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart

@@ -442,6 +442,8 @@ class ConstantsTransformer extends RemovingTransformer {
   /// rewritten.
   bool get keepLocals => backend.keepLocals;
 
+  Library get currentLibrary => _staticTypeContext!.enclosingLibrary;
+
   // Transform the library/class members:
 
   void convertLibrary(Library library) {
@@ -1517,7 +1519,7 @@ class ConstantsTransformer extends RemovingTransformer {
       reportedErrors = [];
     }
     if (!useFallbackExhaustivenessAlgorithm) {
-      Library library = _staticTypeContext!.enclosingLibrary;
+      Library library = currentLibrary;
       for (ExhaustivenessError error in errors) {
         if (error is UnreachableCaseError) {
           if (library.importUri.isScheme('dart') &&
@@ -1558,7 +1560,7 @@ class ConstantsTransformer extends RemovingTransformer {
   TreeNode visitSwitchStatement(
       SwitchStatement node, TreeNode? removalSentinel) {
     TreeNode result = super.visitSwitchStatement(node, removalSentinel);
-    Library library = _staticTypeContext!.enclosingLibrary;
+    Library library = currentLibrary;
     // ignore: unnecessary_null_comparison
     if (library != null) {
       for (SwitchCase switchCase in node.cases) {
@@ -2183,6 +2185,7 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
   final Map<Node, Constant?> nodeCache;
 
   late Map<Class, bool> primitiveEqualCache;
+  late Map<Class, bool> primitiveHashCodeCache;
 
   /// Classes that are considered having a primitive equals but where the
   /// `operator ==` is actually defined through as custom method. For instance
@@ -2210,6 +2213,8 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
   bool get isNonNullableByDefault =>
       _staticTypeContext!.nonNullable == Nullability.nonNullable;
 
+  Library get currentLibrary => _staticTypeContext!.enclosingLibrary;
+
   late ConstantWeakener _weakener;
 
   ConstantEvaluator(this.dartLibrarySupport, this.backend, this.component,
@@ -2247,6 +2252,7 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
       coreTypes.symbolClass: true,
       coreTypes.typeClass: true,
     };
+    primitiveHashCodeCache = <Class, bool>{...primitiveEqualCache};
     _weakener = new ConstantWeakener(this);
   }
 
@@ -3648,20 +3654,37 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
   }
 
   Constant _handleEquals(Expression node, Constant left, Constant right) {
-    if (left is NullConstant ||
-        left is BoolConstant ||
-        left is IntConstant ||
-        left is DoubleConstant ||
-        left is StringConstant ||
-        right is NullConstant) {
-      // [DoubleConstant] uses [identical] to determine equality, so we need
-      // to take the special cases into account.
-      return doubleSpecialCases(left, right) ?? makeBoolConstant(left == right);
+    if (enablePrimitiveEquality) {
+      if (hasPrimitiveEqual(left) ||
+          left is DoubleConstant ||
+          right is NullConstant) {
+        return doubleSpecialCases(left, right) ??
+            makeBoolConstant(left == right);
+      } else {
+        return createEvaluationErrorConstant(
+            node,
+            templateConstEvalEqualsOperandNotPrimitiveEquality.withArguments(
+                left,
+                left.getType(_staticTypeContext!),
+                isNonNullableByDefault));
+      }
     } else {
-      return createEvaluationErrorConstant(
-          node,
-          templateConstEvalInvalidEqualsOperandType.withArguments(
-              left, left.getType(_staticTypeContext!), isNonNullableByDefault));
+      if (left is NullConstant ||
+          left is BoolConstant ||
+          left is IntConstant ||
+          left is DoubleConstant ||
+          left is StringConstant ||
+          right is NullConstant) {
+        // [DoubleConstant] uses [identical] to determine equality, so we need
+        // to take the special cases into account.
+        return doubleSpecialCases(left, right) ??
+            makeBoolConstant(left == right);
+      } else {
+        return createEvaluationErrorConstant(
+            node,
+            templateConstEvalInvalidEqualsOperandType.withArguments(left,
+                left.getType(_staticTypeContext!), isNonNullableByDefault));
+      }
     }
   }
 
@@ -4737,9 +4760,8 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
 
   @override
   Constant visitSymbolLiteral(SymbolLiteral node) {
-    final Reference? libraryReference = node.value.startsWith('_')
-        ? _staticTypeContext!.enclosingLibrary.reference
-        : null;
+    final Reference? libraryReference =
+        node.value.startsWith('_') ? currentLibrary.reference : null;
     return canonicalize(new SymbolConstant(node.value, libraryReference));
   }
 
@@ -4867,6 +4889,8 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
     return null;
   }
 
+  bool get enablePrimitiveEquality => currentLibrary.languageVersion.major >= 3;
+
   bool hasPrimitiveEqual(Constant constant,
       {bool allowPseudoPrimitive = true}) {
     if (intFolder.isInt(constant)) return true;
@@ -4892,9 +4916,13 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
     }
     DartType type = constant.getType(_staticTypeContext!);
     if (type is InterfaceType) {
-      bool result = classHasPrimitiveEqual(type.classNode);
+      Class cls = type.classNode;
+      bool result = classHasPrimitiveEqual(cls);
       if (result && !allowPseudoPrimitive) {
-        result = !pseudoPrimitiveClasses.contains(type.classNode);
+        result = !pseudoPrimitiveClasses.contains(cls);
+      }
+      if (result && enablePrimitiveEquality) {
+        result = classHasPrimitiveHashCode(cls);
       }
       return result;
     }
@@ -4917,6 +4945,27 @@ class ConstantEvaluator implements ExpressionVisitor<Constant> {
         classHasPrimitiveEqual(klass.supertype!.classNode);
   }
 
+  bool classHasPrimitiveHashCode(Class klass) {
+    bool? cached = primitiveHashCodeCache[klass];
+    if (cached != null) return cached;
+    for (Procedure procedure in klass.procedures) {
+      if (procedure.kind == ProcedureKind.Getter &&
+          procedure.name.text == 'hashCode' &&
+          !procedure.isAbstract &&
+          !procedure.isForwardingStub) {
+        return primitiveHashCodeCache[klass] = false;
+      }
+    }
+    for (Field field in klass.fields) {
+      if (field.name.text == 'hashCode') {
+        return primitiveHashCodeCache[klass] = false;
+      }
+    }
+    if (klass.supertype == null) return true; // To be on the safe side
+    return primitiveHashCodeCache[klass] =
+        classHasPrimitiveHashCode(klass.supertype!.classNode);
+  }
+
   BoolConstant makeBoolConstant(bool value) =>
       value ? trueConstant : falseConstant;
 
@@ -6097,3 +6146,10 @@ class _PatternSwitchStatementInfo {
   _PatternSwitchStatementInfo(this.switchIndexVariable,
       this.innerLabeledStatement, this.switchCaseIndexMap);
 }
+
+enum PrimitiveEquality {
+  None,
+  EqualsOnly,
+  HashCodeOnly,
+  EqualsAndHashCode,
+}

pkg/front_end/lib/src/fasta/source/source_loader.dart

@@ -3087,7 +3087,7 @@ class MapEntry<K, V> {
 
 abstract class Map<K, V> extends Iterable {
   factory Map.unmodifiable(other) => null;
-  factory Map.of(o) = Map<E>._of;
+  factory Map.of(o) = Map<K, V>._of;
   external factory Map._of(o);
   Iterable<MapEntry<K, V>> get entries;
   void operator []=(K key, V value) {}

pkg/front_end/messages.status

@@ -107,6 +107,10 @@ ConstEvalDeferredLibrary/example: Fail
 ConstEvalDuplicateElement/example: Fail
 ConstEvalDuplicateKey/example: Fail
 ConstEvalElementImplementsEqual/example: Fail
+ConstEvalElementNotPrimitiveEquality/analyzerCode: Fail
+ConstEvalElementNotPrimitiveEquality/example: Fail
+ConstEvalEqualsOperandNotPrimitiveEquality/analyzerCode: Fail
+ConstEvalEqualsOperandNotPrimitiveEquality/example: Fail
 ConstEvalError/analyzerCode: Fail
 ConstEvalError/example: Fail
 ConstEvalExtension/example: Fail
@@ -138,6 +142,8 @@ ConstEvalIterationInConstList/example: Fail
 ConstEvalIterationInConstMap/example: Fail
 ConstEvalIterationInConstSet/example: Fail
 ConstEvalKeyImplementsEqual/example: Fail
+ConstEvalKeyNotPrimitiveEquality/analyzerCode: Fail
+ConstEvalKeyNotPrimitiveEquality/example: Fail
 ConstEvalNegativeShift/analyzerCode: Fail # http://dartbug.com/33481
 ConstEvalNegativeShift/example: Fail
 ConstEvalNonConstantVariableGet/example: Fail

pkg/front_end/messages.yaml

@@ -139,10 +139,16 @@ ConstEvalElementImplementsEqual:
   problemMessage: "The element '#constant' does not have a primitive operator '=='."
   analyzerCode: CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS
 
+ConstEvalElementNotPrimitiveEquality:
+  problemMessage: "The element '#constant' does not have a primitive equality."
+
 ConstEvalKeyImplementsEqual:
   problemMessage: "The key '#constant' does not have a primitive operator '=='."
   analyzerCode: CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
 
+ConstEvalKeyNotPrimitiveEquality:
+  problemMessage: "The key '#constant' does not have a primitive equality."
+
 ConstEvalCaseImplementsEqual:
   problemMessage: "Case expression '#constant' does not have a primitive operator '=='."
 
@@ -155,6 +161,9 @@ ConstEvalInvalidBinaryOperandType:
 ConstEvalInvalidEqualsOperandType:
   problemMessage: "Binary operator '==' requires receiver constant '#constant' of type 'Null', 'bool', 'int', 'double', or 'String', but was of type '#type'."
 
+ConstEvalEqualsOperandNotPrimitiveEquality:
+  problemMessage: "Binary operator '==' requires receiver constant '#constant' of a type with primitive equality or type 'double', but was of type '#type'."
+
 ConstEvalZeroDivisor:
   problemMessage: "Binary operator '#string' on '#string2' requires non-zero divisor, but divisor was '0'."
   analyzerCode: CONST_EVAL_THROWS_IDBZE