Check equivalence on impact computed with KernelWorldBuilder.

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';
@@ skipping 155 matching lines @@
       a.isSetter == b.isSetter &&
       areElementsEquivalent(library1, library2);
 }
 
 /// Returns `true` if the dynamic uses [a] and [b] are equivalent.
 bool areDynamicUsesEquivalent(DynamicUse a, DynamicUse b) {
   return areSelectorsEquivalent(a.selector, b.selector);
 }
 
 /// Returns `true` if the static uses [a] and [b] are equivalent.
-bool areStaticUsesEquivalent(StaticUse a, StaticUse b) {
-  return a.kind == b.kind && areElementsEquivalent(a.element, b.element);
+bool areStaticUsesEquivalent(StaticUse a, StaticUse b,
+    {TestStrategy strategy: const TestStrategy()}) {
+  return a.kind == b.kind &&
+      strategy.testElements(a, b, 'element', a.element, b.element);
 }
 
 /// Returns `true` if the type uses [a] and [b] are equivalent.
-bool areTypeUsesEquivalent(TypeUse a, TypeUse b) {
-  return a.kind == b.kind && areTypesEquivalent(a.type, b.type);
+bool areTypeUsesEquivalent(TypeUse a, TypeUse b,
+    {TestStrategy strategy: const TestStrategy()}) {
+  return a.kind == b.kind && strategy.testTypes(a, b, 'type', a.type, b.type);
 }
 
 /// Returns `true` if the list literal uses [a] and [b] are equivalent.
-bool areListLiteralUsesEquivalent(ListLiteralUse a, ListLiteralUse b) {
-  return areTypesEquivalent(a.type, b.type) &&
+bool areListLiteralUsesEquivalent(ListLiteralUse a, ListLiteralUse b,
+    {TestStrategy strategy: const TestStrategy()}) {
+  return strategy.testTypes(a, b, 'type', a.type, b.type) &&
       a.isConstant == b.isConstant &&
       a.isEmpty == b.isEmpty;
 }
 
 /// Returns `true` if the map literal uses [a] and [b] are equivalent.
-bool areMapLiteralUsesEquivalent(MapLiteralUse a, MapLiteralUse b) {
-  return areTypesEquivalent(a.type, b.type) &&
+bool areMapLiteralUsesEquivalent(MapLiteralUse a, MapLiteralUse b,
+    {TestStrategy strategy: const TestStrategy()}) {
+  return strategy.testTypes(a, b, 'type', a.type, b.type) &&
       a.isConstant == b.isConstant &&
       a.isEmpty == b.isEmpty;
 }
 
 /// Returns `true` if the access semantics [a] and [b] are equivalent.
 bool areAccessSemanticsEquivalent(AccessSemantics a, AccessSemantics b) {
   if (a.kind != b.kind) return false;
   switch (a.kind) {
     case AccessKind.EXPRESSION:
     case AccessKind.THIS:
@@ skipping 799 matching lines @@
       InterceptorConstantValue value1, InterceptorConstantValue value2) {
     ClassElement cls1 = value1.cls;
     ClassElement cls2 = value2.cls;
     return strategy.testElements(value1, value2, 'cls', cls1, cls2);
   }
 }
 
 /// Tests the equivalence of [impact1] and [impact2] using [strategy].
 bool testResolutionImpactEquivalence(
     ResolutionImpact impact1, ResolutionImpact impact2,
-    [TestStrategy strategy = const TestStrategy()]) {
+    {TestStrategy strategy = const TestStrategy()}) {
   return strategy.testSets(impact1, impact2, 'constSymbolNames',
           impact1.constSymbolNames, impact2.constSymbolNames) &&
       strategy.testSets(
           impact1,
           impact2,
           'constantLiterals',
           impact1.constantLiterals,
           impact2.constantLiterals,
           areConstantsEquivalent) &&
       strategy.testSets(impact1, impact2, 'dynamicUses', impact1.dynamicUses,
           impact2.dynamicUses, areDynamicUsesEquivalent) &&
       strategy.testSets(
           impact1, impact2, 'features', impact1.features, impact2.features) &&
-      strategy.testSets(impact1, impact2, 'listLiterals', impact1.listLiterals,
-          impact2.listLiterals, areListLiteralUsesEquivalent) &&
-      strategy.testSets(impact1, impact2, 'mapLiterals', impact1.mapLiterals,
-          impact2.mapLiterals, areMapLiteralUsesEquivalent) &&
-      strategy.testSets(impact1, impact2, 'staticUses', impact1.staticUses,
-          impact2.staticUses, areStaticUsesEquivalent) &&
-      strategy.testSets(impact1, impact2, 'typeUses', impact1.typeUses,
-          impact2.typeUses, areTypeUsesEquivalent) &&
+      strategy.testSets(
+          impact1,
+          impact2,
+          'listLiterals',
+          impact1.listLiterals,
+          impact2.listLiterals,
+          (a, b) => areListLiteralUsesEquivalent(a, b,
+              strategy: strategy.testOnly)) &&
+      strategy.testSets(
+          impact1,
+          impact2,
+          'mapLiterals',
+          impact1.mapLiterals,
+          impact2.mapLiterals,
+          (a, b) =>
+              areMapLiteralUsesEquivalent(a, b, strategy: strategy.testOnly)) &&
+      strategy.testSets(
+          impact1,
+          impact2,
+          'staticUses',
+          impact1.staticUses,
+          impact2.staticUses,
+          (a, b) =>
+              areStaticUsesEquivalent(a, b, strategy: strategy.testOnly)) &&
+      strategy.testSets(
+          impact1,
+          impact2,
+          'typeUses',
+          impact1.typeUses,
+          impact2.typeUses,
+          (a, b) => areTypeUsesEquivalent(a, b, strategy: strategy.testOnly)) &&
       strategy.testSets(impact1, impact2, 'nativeData', impact1.nativeData,
           impact2.nativeData, testNativeBehavior);
 }
 
 /// Tests the equivalence of [resolvedAst1] and [resolvedAst2] using [strategy].
 bool testResolvedAstEquivalence(
     ResolvedAst resolvedAst1, ResolvedAst resolvedAst2,
     [TestStrategy strategy = const TestStrategy()]) {
   if (!strategy.test(resolvedAst1, resolvedAst1, 'kind', resolvedAst1.kind,
       resolvedAst2.kind)) {
@@ skipping 1029 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);
 }