Check equivalence of closed world based on kernel elements.

tests/compiler/dart2js/serialization/model_test_helper.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.serialization_model_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
@@ skipping 89 matching lines @@
     checkAllImpacts(compilerNormal, compilerDeserialized, verbose: verbose);
     checkResolutionEnqueuers(
         compilerNormal.backend.backendUsage,
         compilerDeserialized.backend.backendUsage,
         compilerNormal.enqueuer.resolution,
         compilerDeserialized.enqueuer.resolution,
         verbose: verbose);
     checkClosedWorlds(
         compilerNormal.resolutionWorldBuilder.closedWorldForTesting,
         compilerDeserialized.resolutionWorldBuilder.closedWorldForTesting,
+        areElementsEquivalent,
         verbose: verbose);
     checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
   });
 }
 
 void checkResolutionEnqueuers(
     BackendUsage backendUsage1,
     BackendUsage backendUsage2,
     ResolutionEnqueuer enqueuer1,
     ResolutionEnqueuer enqueuer2,
@@ skipping 44 matching lines @@
       "JavaScriptBackend.hasFunctionApplySupport mismatch");
   Expect.equals(
       backendUsage1.isRuntimeTypeUsed,
       backendUsage2.isRuntimeTypeUsed,
       "JavaScriptBackend.hasRuntimeTypeSupport mismatch");
   Expect.equals(backendUsage1.isIsolateInUse, backendUsage2.isIsolateInUse,
       "JavaScriptBackend.hasIsolateSupport mismatch");
 }
 
 void checkClosedWorlds(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
+    bool elementEquivalence(Entity a, Entity b),
     {bool verbose: false}) {
+  if (verbose) {
+    print(closedWorld1.dump());
+    print(closedWorld2.dump());
+  }
   checkClassHierarchyNodes(
       closedWorld1,
       closedWorld2,
       closedWorld1
           .getClassHierarchyNode(closedWorld1.commonElements.objectClass),
       closedWorld2
           .getClassHierarchyNode(closedWorld2.commonElements.objectClass),
+      elementEquivalence,
       verbose: verbose);
 }
 
 void checkBackendInfo(Compiler compilerNormal, Compiler compilerDeserialized,
     {bool verbose: false}) {
   checkSets(
       compilerNormal.enqueuer.resolution.processedEntities,
       compilerDeserialized.enqueuer.resolution.processedEntities,
       "Processed element mismatch",
       areElementsEquivalent, onSameElement: (a, b) {
@@ skipping 105 matching lines @@
   JavaScriptBackend backend1 = compiler1.backend;
   JavaScriptBackend backend2 = compiler2.backend;
   Expect.equals(
       backend1.inlineCache.getCurrentCacheDecisionForTesting(element1),
       backend2.inlineCache.getCurrentCacheDecisionForTesting(element2),
       "Inline cache decision mismatch for $element1 vs $element2");
 
   checkElementOutputUnits(compiler1, compiler2, element1, element2);
 }
 
-void checkMixinUses(ClosedWorld closedWorld1, ClosedWorld closedWorld2,
-    ClassElement class1, ClassElement class2,
+void checkMixinUses(
+    ClosedWorld closedWorld1,
+    ClosedWorld closedWorld2,
+    ClassEntity class1,
+    ClassEntity class2,
+    bool elementEquivalence(Entity a, Entity b),
     {bool verbose: false}) {
   checkSets(closedWorld1.mixinUsesOf(class1), closedWorld2.mixinUsesOf(class2),
-      "Mixin uses of $class1 vs $class2", areElementsEquivalent,
+      "Mixin uses of $class1 vs $class2", elementEquivalence,
       verbose: verbose);
 }
 
 void checkClassHierarchyNodes(
     ClosedWorld closedWorld1,
     ClosedWorld closedWorld2,
     ClassHierarchyNode node1,
     ClassHierarchyNode node2,
+    bool elementEquivalence(Entity a, Entity b),
     {bool verbose: false}) {
   if (verbose) {
     print('Checking $node1 vs $node2');
   }
-  ClassElement cls1 = node1.cls;
-  ClassElement cls2 = node2.cls;
-  Expect.isTrue(areElementsEquivalent(cls1, cls2),
+  ClassEntity cls1 = node1.cls;
+  ClassEntity cls2 = node2.cls;
+  Expect.isTrue(elementEquivalence(cls1, cls2),
       "Element identity mismatch for ${cls1} vs ${cls2}.");
   Expect.equals(
       node1.isDirectlyInstantiated,
       node2.isDirectlyInstantiated,
       "Value mismatch for 'isDirectlyInstantiated' "
       "for ${cls1} vs ${cls2}.");
   Expect.equals(
       node1.isIndirectlyInstantiated,
       node2.isIndirectlyInstantiated,
       "Value mismatch for 'isIndirectlyInstantiated' "
       "for ${node1.cls} vs ${node2.cls}.");
   // TODO(johnniwinther): Enforce a canonical and stable order on direct
   // subclasses.
   for (ClassHierarchyNode child in node1.directSubclasses) {
     bool found = false;
     for (ClassHierarchyNode other in node2.directSubclasses) {
-      ClassElement child1 = child.cls;
-      ClassElement child2 = other.cls;
-      if (areElementsEquivalent(child1, child2)) {
-        checkClassHierarchyNodes(closedWorld1, closedWorld2, child, other,
+      ClassEntity child1 = child.cls;
+      ClassEntity child2 = other.cls;
+      if (elementEquivalence(child1, child2)) {
+        checkClassHierarchyNodes(
+            closedWorld1, closedWorld2, child, other, elementEquivalence,
             verbose: verbose);
         found = true;
         break;
       }
     }
     if (!found) {
       if (child.isInstantiated) {
         print('Missing subclass ${child.cls} of ${node1.cls} '
             'in ${node2.directSubclasses}');
         print(closedWorld1.dump(
             verbose ? closedWorld1.commonElements.objectClass : node1.cls));
         print(closedWorld2.dump(
             verbose ? closedWorld2.commonElements.objectClass : node2.cls));
       }
       Expect.isFalse(
           child.isInstantiated,
           'Missing subclass ${child.cls} of ${node1.cls} in '
           '${node2.directSubclasses}');
     }
   }
-  checkMixinUses(closedWorld1, closedWorld2, node1.cls, node2.cls,
+  checkMixinUses(
+      closedWorld1, closedWorld2, node1.cls, node2.cls, elementEquivalence,
       verbose: verbose);
 }
 
 bool areLocalsEquivalent(Local a, Local b) {
   if (a == b) return true;
   if (a == null || b == null) return false;
 
   if (a is Element) {
     return b is Element && areElementsEquivalent(a as Element, b as Element);
   } else {
@@ skipping 80 matching lines @@
 }
 
 bool areInstancesEquivalent(Instance instance1, Instance instance2,
     bool typeEquivalence(DartType a, DartType b)) {
   InterfaceType type1 = instance1.type;
   InterfaceType type2 = instance2.type;
   return typeEquivalence(type1, type2) &&
       instance1.kind == instance2.kind &&
       instance1.isRedirection == instance2.isRedirection;
 }