Register mixin use from modelz.

pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, 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.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'common/backend_api.dart' show Backend;
 import 'compiler.dart' show Compiler;
@@ skipping 442 matching lines @@
     assert(isClosed);
     if (_liveMixinUses == null) {
       _liveMixinUses = new Map<ClassElement, List<MixinApplicationElement>>();
       for (ClassElement mixin in _mixinUses.keys) {
         List<MixinApplicationElement> uses = <MixinApplicationElement>[];
 
         void addLiveUse(MixinApplicationElement mixinApplication) {
           if (isInstantiated(mixinApplication)) {
             uses.add(mixinApplication);
           } else if (mixinApplication.isNamedMixinApplication) {
-            List<MixinApplicationElement> next = _mixinUses[mixinApplication];
+            Set<MixinApplicationElement> next = _mixinUses[mixinApplication];
             if (next != null) {
               next.forEach(addLiveUse);
             }
           }
         }
 
         _mixinUses[mixin].forEach(addLiveUse);
         if (uses.isNotEmpty) {
           _liveMixinUses[mixin] = uses;
         }
@@ skipping 30 matching lines @@
   }
 
   final Compiler compiler;
   Backend get backend => compiler.backend;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
   final Set<TypedefElement> allTypedefs = new Set<TypedefElement>();
 
-  final Map<ClassElement, List<MixinApplicationElement>> _mixinUses =
-      new Map<ClassElement, List<MixinApplicationElement>>();
+  final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
+      new Map<ClassElement, Set<MixinApplicationElement>>();
   Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
 
   final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses =
       new Map<ClassElement, Set<ClassElement>>();
 
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassElement, ClassHierarchyNode> _classHierarchyNodes =
       <ClassElement, ClassHierarchyNode>{};
   final Map<ClassElement, ClassSet> _classSets = <ClassElement, ClassSet>{};
@@ skipping 72 matching lines @@
     return _classSets.putIfAbsent(cls, () {
       ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
       ClassSet classSet = new ClassSet(node);
 
       for (InterfaceType type in cls.allSupertypes) {
         // TODO(johnniwinther): Optimization: Avoid adding [cls] to
         // superclasses.
         ClassSet subtypeSet = _ensureClassSet(type.element);
         subtypeSet.addSubtype(node);
       }
+      if (cls.isMixinApplication) {
+        // TODO(johnniwinther): Store this in the [ClassSet].
+        MixinApplicationElement mixinApplication = cls;
+        if (mixinApplication.mixin != null) {
+          // If [mixinApplication] is malformed [mixin] is `null`.
+          registerMixinUse(mixinApplication, mixinApplication.mixin);
+        }
+      }
+
       return classSet;
     });
   }
 
   void _updateSuperClassHierarchyNodeForClass(ClassHierarchyNode node) {
     // Ensure that classes implicitly implementing `Function` are in its
     // subtype set.
     ClassElement cls = node.cls;
     if (cls != coreClasses.functionClass &&
         cls.implementsFunction(coreClasses)) {
@@ skipping 62 matching lines @@
     getClassHierarchyNode(coreClasses.objectClass)
         .printOn(sb, ' ', instantiatedOnly: cls == null, withRespectTo: cls);
     return sb.toString();
   }
 
   void registerMixinUse(
       MixinApplicationElement mixinApplication, ClassElement mixin) {
     // TODO(johnniwinther): Add map restricted to live classes.
     // We don't support patch classes as mixin.
     assert(mixin.isDeclaration);
-    List<MixinApplicationElement> users = _mixinUses.putIfAbsent(
-        mixin, () => new List<MixinApplicationElement>());
+    Set<MixinApplicationElement> users = _mixinUses.putIfAbsent(
+        mixin, () => new Set<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
   bool hasAnyUserDefinedGetter(Selector selector, ti.TypeMask mask) {
     return allFunctions.filter(selector, mask).any((each) => each.isGetter);
   }
 
   void registerUsedElement(Element element) {
     if (element.isInstanceMember && !element.isAbstract) {
       allFunctions.add(element);
@@ skipping 115 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !compiler.options.hasIncrementalSupport;
 }