Prepare equivalence strategies for testing entities.

pkg/compiler/lib/src/serialization/equivalence.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// Functions for asserting equivalence across serialization.
 
 library dart2js.serialization.equivalence;
 
 import '../closure.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
+import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../elements/visitor.dart';
 import '../js_backend/backend_serialization.dart'
     show NativeBehaviorSerialization;
 import '../native/native.dart' show NativeBehavior;
 import '../resolution/access_semantics.dart';
 import '../resolution/send_structure.dart';
 import '../resolution/tree_elements.dart';
 import '../tokens/token.dart';
 import '../tree/nodes.dart';
 import '../universe/selector.dart';
 import '../universe/feature.dart';
 import '../universe/use.dart';
 import '../util/util.dart';
 import 'resolved_ast_serialization.dart';
 
+typedef bool Equivalence<E>(E a, E b, {TestStrategy strategy});
+
 /// Equality based equivalence function.
 bool equality(a, b) => a == b;
 
 /// Returns `true` if the elements in [a] and [b] are pair-wise equivalent
 /// according to [elementEquivalence].
 bool areListsEquivalent(List a, List b,
     [bool elementEquivalence(a, b) = equality]) {
   if (a.length != b.length) return false;
   for (int i = 0; i < a.length && i < b.length; i++) {
     if (!elementEquivalence(a[i], b[i])) {
@@ skipping 43 matching lines @@
       }
     }
     if (!found) {
       return false;
     }
   }
   return remaining.isEmpty;
 }
 
 /// Returns `true` if elements [a] and [b] are equivalent.
-bool areElementsEquivalent(Element a, Element b) {
+bool areElementsEquivalent(Element a, Element b, {TestStrategy strategy}) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
-  return const ElementIdentityEquivalence().visit(a, b);
+  return new ElementIdentityEquivalence(strategy ?? const TestStrategy())
+      .visit(a, b);
 }
 
 /// Returns `true` if types [a] and [b] are equivalent.
-bool areTypesEquivalent(DartType a, DartType b) {
+bool areTypesEquivalent(DartType a, DartType b, {TestStrategy strategy}) {
   if (identical(a, b)) return true;
   if (a == null || b == null) return false;
-  return const TypeEquivalence().visit(a, b);
+  return new TypeEquivalence(strategy ?? const TestStrategy()).visit(a, b);
 }
 
 /// Returns `true` if constants [exp1] and [exp2] are equivalent.
-bool areConstantsEquivalent(ConstantExpression exp1, ConstantExpression exp2) {
+bool areConstantsEquivalent(ConstantExpression exp1, ConstantExpression exp2,
+    {TestStrategy strategy}) {
   if (identical(exp1, exp2)) return true;
   if (exp1 == null || exp2 == null) return false;
-  return const ConstantEquivalence().visit(exp1, exp2);
+  return new ConstantEquivalence(strategy ?? const TestStrategy())
+      .visit(exp1, exp2);
 }
 
 /// Returns `true` if constant values [value1] and [value2] are equivalent.
-bool areConstantValuesEquivalent(ConstantValue value1, ConstantValue value2) {
+bool areConstantValuesEquivalent(ConstantValue value1, ConstantValue value2,
+    {TestStrategy strategy}) {
   if (identical(value1, value2)) return true;
   if (value1 == null || value2 == null) return false;
-  return const ConstantValueEquivalence().visit(value1, value2);
+  return new ConstantValueEquivalence(strategy ?? const TestStrategy())
+      .visit(value1, value2);
 }
 
 /// Returns `true` if the lists of elements, [a] and [b], are equivalent.
 bool areElementListsEquivalent(List<Element> a, List<Element> b) {
   return areListsEquivalent(a, b, areElementsEquivalent);
 }
 
 /// Returns `true` if the lists of types, [a] and [b], are equivalent.
 bool areTypeListsEquivalent(
     List<ResolutionDartType> a, List<ResolutionDartType> b) {
@@ skipping 196 matching lines @@
 bool areNodesEquivalent(Node node1, Node node2) {
   if (identical(node1, node2)) return true;
   if (node1 == null || node2 == null) return false;
   return node1.accept1(const NodeEquivalenceVisitor(), node2);
 }
 
 /// Strategy for testing equivalence.
 ///
 /// Use this strategy to determine equivalence without failing on inequivalence.
 class TestStrategy {
-  const TestStrategy();
+  final Equivalence<Entity> elementEquivalence;
+  final Equivalence<DartType> typeEquivalence;
+  final Equivalence<ConstantExpression> constantEquivalence;
+  final Equivalence<ConstantValue> constantValueEquivalence;
+
+  const TestStrategy(
+      {this.elementEquivalence: areElementsEquivalent,
+      this.typeEquivalence: areTypesEquivalent,
+      this.constantEquivalence: areConstantsEquivalent,
+      this.constantValueEquivalence: areConstantValuesEquivalent});
+
+  /// An equivalence [TestStrategy] that doesn't throw on inequivalence.
+  TestStrategy get testOnly => this;
 
   bool test(var object1, var object2, String property, var value1, var value2,
       [bool equivalence(a, b) = equality]) {
     return equivalence(value1, value2);
   }
 
   bool testLists(
       Object object1, Object object2, String property, List list1, List list2,
       [bool elementEquivalence(a, b) = equality]) {
     return areListsEquivalent(list1, list2, elementEquivalence);
   }
 
   bool testSets(
       var object1, var object2, String property, Iterable set1, Iterable set2,
       [bool elementEquivalence(a, b) = equality]) {
     return areSetsEquivalent(set1, set2, elementEquivalence);
   }
 
   bool testMaps(var object1, var object2, String property, Map map1, Map map2,
       [bool keyEquivalence(a, b) = equality,
       bool valueEquivalence(a, b) = equality]) {
     return areMapsEquivalent(map1, map2, keyEquivalence, valueEquivalence);
   }
 
   bool testElements(Object object1, Object object2, String property,
-      Element element1, Element element2) {
-    return areElementsEquivalent(element1, element2);
+      Entity element1, Entity element2) {
+    return test(object1, object2, property, element1, element2,
+        (a, b) => elementEquivalence(a, b, strategy: this));
   }
 
   bool testTypes(Object object1, Object object2, String property,
-      ResolutionDartType type1, ResolutionDartType type2) {
-    return areTypesEquivalent(type1, type2);
+      DartType type1, DartType type2) {
+    return test(object1, object2, property, type1, type2,
+        (a, b) => typeEquivalence(a, b, strategy: this));
   }
 
   bool testConstants(Object object1, Object object2, String property,
       ConstantExpression exp1, ConstantExpression exp2) {
-    return areConstantsEquivalent(exp1, exp2);
+    return test(object1, object2, property, exp1, exp2,
+        (a, b) => constantEquivalence(a, b, strategy: this));
   }
 
   bool testConstantValues(Object object1, Object object2, String property,
       ConstantValue value1, ConstantValue value2) {
-    return areConstantValuesEquivalent(value1, value2);
+    return test(object1, object2, property, value1, value2,
+        (a, b) => constantValueEquivalence(a, b, strategy: this));
   }
 
   bool testTypeLists(Object object1, Object object2, String property,
-      List<ResolutionDartType> list1, List<ResolutionDartType> list2) {
-    return areTypeListsEquivalent(list1, list2);
+      List<DartType> list1, List<DartType> list2) {
+    return testLists(object1, object2, property, list1, list2,
+        (a, b) => typeEquivalence(a, b, strategy: this));
   }
 
   bool testConstantLists(Object object1, Object object2, String property,
       List<ConstantExpression> list1, List<ConstantExpression> list2) {
-    return areConstantListsEquivalent(list1, list2);
+    return testLists(object1, object2, property, list1, list2,
+        (a, b) => constantEquivalence(a, b, strategy: this));
   }
 
   bool testConstantValueLists(Object object1, Object object2, String property,
       List<ConstantValue> list1, List<ConstantValue> list2) {
-    return areConstantValueListsEquivalent(list1, list2);
+    return testLists(object1, object2, property, list1, list2,
+        (a, b) => constantValueEquivalence(a, b, strategy: this));
   }
 
   bool testNodes(
       Object object1, Object object2, String property, Node node1, Node node2) {
     return areNodesEquivalent(node1, node2);
   }
 }
 
 /// Visitor that checks for equivalence of [Element]s.
 class ElementIdentityEquivalence extends BaseElementVisitor<bool, Element> {
@@ skipping 1645 matching lines @@
 }
 
 bool areMetadataAnnotationsEquivalent(
     MetadataAnnotation metadata1, MetadataAnnotation metadata2) {
   if (metadata1 == metadata2) return true;
   if (metadata1 == null || metadata2 == null) return false;
   return areElementsEquivalent(
           metadata1.annotatedElement, metadata2.annotatedElement) &&
       areConstantsEquivalent(metadata1.constant, metadata2.constant);
 }