Register mixin use from modelz.

tests/compiler/dart2js/serialization/model_test.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 48 matching lines @@
    bool verbose: false}) async {
 
   print('------------------------------------------------------------------');
   print('compile normal');
   print('------------------------------------------------------------------');
   Compiler compilerNormal = compilerFor(
       memorySourceFiles: sourceFiles,
       options: [Flags.analyzeOnly]);
   compilerNormal.resolution.retainCachesForTesting = true;
   await compilerNormal.run(entryPoint);
+  compilerNormal.phase = Compiler.PHASE_DONE_RESOLVING;
   compilerNormal.world.populate();
 
   print('------------------------------------------------------------------');
   print('compile deserialized');
   print('------------------------------------------------------------------');
   Compiler compilerDeserialized = compilerFor(
       memorySourceFiles: sourceFiles,
       options: [Flags.analyzeOnly]);
   compilerDeserialized.resolution.retainCachesForTesting = true;
   deserialize(compilerDeserialized, serializedData);
   await compilerDeserialized.run(entryPoint);
+  compilerDeserialized.phase = Compiler.PHASE_DONE_RESOLVING;
   compilerDeserialized.world.populate();
 
   checkAllImpacts(
       compilerNormal, compilerDeserialized,
       verbose: verbose);
 
   checkSets(
       compilerNormal.resolverWorld.directlyInstantiatedClasses,
       compilerDeserialized.resolverWorld.directlyInstantiatedClasses,
       "Directly instantiated classes mismatch",
@@ skipping 15 matching lines @@
       verbose: verbose);
 
   checkSets(
       compilerNormal.enqueuer.resolution.processedElements,
       compilerDeserialized.enqueuer.resolution.processedElements,
       "Processed element mismatch",
       areElementsEquivalent,
       verbose: verbose);
 
   checkClassHierarchyNodes(
-    compilerNormal.world.getClassHierarchyNode(
-        compilerNormal.coreClasses.objectClass),
-    compilerDeserialized.world.getClassHierarchyNode(
-        compilerDeserialized.coreClasses.objectClass),
-    verbose: verbose);
+      compilerNormal,
+      compilerDeserialized,
+      compilerNormal.world.getClassHierarchyNode(
+          compilerNormal.coreClasses.objectClass),
+      compilerDeserialized.world.getClassHierarchyNode(
+          compilerDeserialized.coreClasses.objectClass),
+      verbose: verbose);
+}
+
+void checkMixinUses(
+    Compiler compiler1, Compiler compiler2,
+    ClassElement class1, ClassElement class2,
+    {bool verbose: false}) {
+
+  checkSets(
+      compiler1.world.mixinUsesOf(class1),
+      compiler2.world.mixinUsesOf(class2),
+      "Mixin uses of $class1 vs $class2",
+      areElementsEquivalent,
+      verbose: verbose);
+
 }
 
 void checkClassHierarchyNodes(
-    ClassHierarchyNode a, ClassHierarchyNode b,
+    Compiler compiler1,
+    Compiler compiler2,
+    ClassHierarchyNode node1, ClassHierarchyNode node2,
     {bool verbose: false}) {
   if (verbose) {
-    print('Checking $a vs $b');
+    print('Checking $node1 vs $node2');
   }
   Expect.isTrue(
-      areElementsEquivalent(a.cls, b.cls),
-      "Element identity mismatch for ${a.cls} vs ${b.cls}.");
+      areElementsEquivalent(node1.cls, node2.cls),
+      "Element identity mismatch for ${node1.cls} vs ${node2.cls}.");
   Expect.equals(
-      a.isDirectlyInstantiated,
-      b.isDirectlyInstantiated,
-      "Value mismatch for 'isDirectlyInstantiated' for ${a.cls} vs ${b.cls}.");
+      node1.isDirectlyInstantiated,
+      node2.isDirectlyInstantiated,
+      "Value mismatch for 'isDirectlyInstantiated' "
+      "for ${node1.cls} vs ${node2.cls}.");
   Expect.equals(
-      a.isIndirectlyInstantiated,
-      b.isIndirectlyInstantiated,
+      node1.isIndirectlyInstantiated,
+      node2.isIndirectlyInstantiated,
       "Value mismatch for 'isIndirectlyInstantiated' "
-      "for ${a.cls} vs ${b.cls}.");
+      "for ${node1.cls} vs ${node2.cls}.");
   // TODO(johnniwinther): Enforce a canonical and stable order on direct
   // subclasses.
-  for (ClassHierarchyNode child in a.directSubclasses) {
+  for (ClassHierarchyNode child in node1.directSubclasses) {
     bool found = false;
-    for (ClassHierarchyNode other in b.directSubclasses) {
+    for (ClassHierarchyNode other in node2.directSubclasses) {
       if (areElementsEquivalent(child.cls, other.cls)) {
-        checkClassHierarchyNodes(child, other,
-            verbose: verbose);
+        checkClassHierarchyNodes(compiler1, compiler2,
+            child, other, verbose: verbose);
         found = true;
         break;
       }
     }
     if (!found) {
-      Expect.isFalse(
-          child.isInstantiated, 'Missing subclass ${child.cls} of ${a.cls}');
+      Expect.isFalse(child.isInstantiated,
+          'Missing subclass ${child.cls} of ${node1.cls}');
     }
   }
+  checkMixinUses(compiler1, compiler2, node1.cls, node2.cls, verbose: verbose);
 }
 
 void checkSets(
     Iterable set1,
     Iterable set2,
     String messagePrefix,
     bool areEquivalent(a, b),
     {bool failOnUnfound: true,
      bool verbose: false}) {
   List common = [];
@@ skipping 16 matching lines @@
 
     if (failOnUnfound || remaining.isNotEmpty) {
       Expect.fail(message);
     } else {
       print(message);
     }
   } else if (verbose) {
     print(message);
   }
 }