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 19 matching lines @@
       compilerDeserialized.enqueuer.resolution.processedElements,
       "Processed element mismatch",
       areElementsEquivalent,
       verbose: verbose);
 
   checkClassHierarchyNodes(
     compilerNormal.world.getClassHierarchyNode(
         compilerNormal.coreClasses.objectClass),
     compilerDeserialized.world.getClassHierarchyNode(
         compilerDeserialized.coreClasses.objectClass),
+    onClasses: (a, b) {
+      checkMixinUses(
+          compilerNormal, compilerDeserialized, a, b, verbose: verbose);
+    },
     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,
-    {bool verbose: false}) {
+    {void onClasses(ClassElement a, ClassElement b),
+     bool verbose: false}) {
   if (verbose) {
     print('Checking $a vs $b');
   }
   Expect.isTrue(
       areElementsEquivalent(a.cls, b.cls),
       "Element identity mismatch for ${a.cls} vs ${b.cls}.");
   Expect.equals(
       a.isDirectlyInstantiated,
       b.isDirectlyInstantiated,
       "Value mismatch for 'isDirectlyInstantiated' for ${a.cls} vs ${b.cls}.");
   Expect.equals(
       a.isIndirectlyInstantiated,
       b.isIndirectlyInstantiated,
       "Value mismatch for 'isIndirectlyInstantiated' "
       "for ${a.cls} vs ${b.cls}.");
   // TODO(johnniwinther): Enforce a canonical and stable order on direct
   // subclasses.
   for (ClassHierarchyNode child in a.directSubclasses) {
     bool found = false;
     for (ClassHierarchyNode other in b.directSubclasses) {
       if (areElementsEquivalent(child.cls, other.cls)) {
         checkClassHierarchyNodes(child, other,
-            verbose: verbose);
+            onClasses: onClasses, verbose: verbose);
         found = true;
         break;
       }
     }
     if (!found) {
       Expect.isFalse(
           child.isInstantiated, 'Missing subclass ${child.cls} of ${a.cls}');
     }
   }
+  onClasses(a.cls, b.cls);

[Siggi Cherem (dart-lang), 2016/05/10 17:17:48]

nit: the `onClasses` callback argument feels like "this is extra stuff that is
not required to check the equivalence of class hierarchy nodes."

To make it clear that this is a core part of the checks, I would pass in the
compilers here and call checkMixinUses directly. If you prefer to keep the
compiler arguments outside this function, then consider making `onClasses`
mandatory and rename it to something else that highlights it is not really
optional, maybe `checkMixins`?

[Johnni Winther, 2016/05/11 07:53:12]

Done.

 }
 
 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);
   }
 }