Enqueue superclasses instead of supertypes.

pkg/compiler/lib/src/universe/universe.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 universe;
 
 import 'dart:collection';
 
 import '../common/names.dart' show
     Identifiers,
@@ skipping 23 matching lines @@
   final Selector selector;
   final ReceiverMask mask;
 
   UniverseSelector(this.selector, this.mask);
 
   bool appliesUnnamed(Element element, ClassWorld world) {
     return selector.appliesUnnamed(element, world) &&
         (mask == null || mask.canHit(element, selector, world));
   }
 
+  int get hashCode => selector.hashCode * 13 + mask.hashCode * 17;
+
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! UniverseSelector) return false;
+    return selector == other.selector && mask == other.mask;
+  }
+
   String toString() => '$selector,$mask';
 }
 
 /// A potential receiver for a dynamic call site.
 abstract class ReceiverMask {
   /// Returns whether [element] is a potential target when being
   /// invoked on this receiver mask. [selector] is used to ensure library
   /// privacy is taken into account.
   bool canHit(Element element, Selector selector, ClassWorld classWorld);
 }
@@ skipping 57 matching lines @@
   ///
   /// See [_directlyInstantiatedClasses].
   final Set<DartType> _instantiatedTypes = new Set<DartType>();
 
   /// The set of all instantiated classes, either directly, as superclasses or
   /// as supertypes.
   ///
   /// Invariant: Elements are declaration elements.
   final Set<ClassElement> _allInstantiatedClasses = new Set<ClassElement>();
 
+  /// Classes implemented by directly instantiated classes.
+  final Set<ClassElement> _implementedClasses = new Set<ClassElement>();
+
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   final Set<FieldElement> allReferencedStaticFields = new Set<FieldElement>();
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: Elements are declaration elements.
    */
@@ skipping 68 matching lines @@
   }
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   ///
   /// See [directlyInstantiatedClasses].
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<DartType> get instantiatedTypes => _instantiatedTypes;
 
   /// Returns `true` if [cls] is considered to be instantiated, either directly,
-  /// through subclasses or through subtypes. The latter case only contains
-  /// spurious information from instatiations through factory constructors and
-  /// mixins.
+  /// through subclasses.
   // TODO(johnniwinther): Improve semantic precision.
   bool isInstantiated(ClassElement cls) {
-    return _allInstantiatedClasses.contains(cls);
+    return _allInstantiatedClasses.contains(cls.declaration);
+  }
+
+  /// Returns `true` if [cls] is considered to be implemented by an
+  /// instantiated class, either directly, through subclasses or through
+  /// subtypes. The latter case only contains spurious information from
+  /// instantiations through factory constructors and mixins.
+  // TODO(johnniwinther): Improve semantic precision.
+  bool isImplemented(ClassElement cls) {
+    return _implementedClasses.contains(cls.declaration);
   }
 
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(InterfaceType type,
-                                 {bool byMirrors: false}) {
+                                 {bool byMirrors: false,
+                                  void onImplemented(ClassElement cls)}) {
     _instantiatedTypes.add(type);
     ClassElement cls = type.element;
     if (!cls.isAbstract
         // We can't use the closed-world assumption with native abstract
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
         || cls.isNative
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
         // TODO(herhut): Track classes required by mirrors seperately.
         || byMirrors) {
       _directlyInstantiatedClasses.add(cls);
     }
 
-    // TODO(johnniwinther): Replace this by separate more specific mappings.
-    if (!_allInstantiatedClasses.add(cls)) return;
-    cls.allSupertypes.forEach((InterfaceType supertype) {
-      _allInstantiatedClasses.add(supertype.element);
-    });
+    // TODO(johnniwinther): Replace this by separate more specific mappings that
+    // include the type arguments.
+    if (_implementedClasses.add(cls)) {
+      onImplemented(cls);
+      cls.allSupertypes.forEach((InterfaceType supertype) {
+        if (_implementedClasses.add(supertype.element)) {
+          onImplemented(supertype.element);
+        }
+      });
+    }
+    while (cls != null) {
+      if (!_allInstantiatedClasses.add(cls)) {
+        return;
+      }
+      cls = cls.superclass;
+    }
   }
 
   bool _hasMatchingSelector(Map<Selector, ReceiverMaskSet> selectors,
                             Element member,
                             World world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member, world)) {
         ReceiverMaskSet masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
@@ skipping 111 matching lines @@
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
           return closure.executableContext == element;
         }));
   }
 }