Revert "Enqueue superclasses instead of supertypes."

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/backend_api.dart' show
     Backend;
@@ skipping 48 matching lines @@
 
   /// The [ClassElement] for the [double] class defined in 'dart:core'.
   ClassElement get doubleClass;
 
   /// The [ClassElement] for the [String] class defined in 'dart:core'.
   ClassElement get stringClass;
 
   /// Returns `true` if [cls] is instantiated.
   bool isInstantiated(ClassElement cls);
 
-  /// Returns `true` if [cls] is implemented by an instantiated class.
-  bool isImplemented(ClassElement cls);
-
   /// Returns `true` if the class world is closed.
   bool get isClosed;
 
   /// Return `true` if [x] is a subclass of [y].
   bool isSubclassOf(ClassElement x, ClassElement y);
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassElement x, ClassElement y);
 
@@ skipping 37 matching lines @@
   /// Returns `true` if any live class that mixes in [mixin] is also a subclass
   /// of [superclass].
   bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement mixin);
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
 
   /// Returns `true` if closed-world assumptions can be made, that is,
   /// incremental compilation isn't enabled.
   bool get hasClosedWorldAssumption;
-
-  /// Returns a string representation of the closed world.
-  String dump();
 }
 
 class World implements ClassWorld {
   ClassElement get objectClass => compiler.objectClass;
   ClassElement get functionClass => compiler.functionClass;
   ClassElement get boolClass => compiler.boolClass;
   ClassElement get numClass => compiler.numClass;
   ClassElement get intClass => compiler.intClass;
   ClassElement get doubleClass => compiler.doubleClass;
   ClassElement get stringClass => compiler.stringClass;
   ClassElement get nullClass => compiler.nullClass;
 
   /// Cache of [ti.FlatTypeMask]s grouped by the 8 possible values of the
   /// [ti.FlatTypeMask.flags] property.
   List<Map<ClassElement, ti.TypeMask>> canonicalizedTypeMasks =
       new List<Map<ClassElement, ti.TypeMask>>.filled(8, null);
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return
       invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
       invariant(cls, cls.isResolved,
-                message: '$cls must be resolved.')/* &&
-      // TODO(johnniwinther): Reinsert this or similar invariant.
+                message: '$cls must be resolved.') &&
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
-                 message: '$cls is not instantiated.'))*/;
+                 message: '$cls is not instantiated.'));
  }
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassElement x, ClassElement y) {
     assert(checkInvariants(x));
     assert(checkInvariants(y, mustBeInstantiated: false));
 
     if (y == objectClass) return true;
     if (x == objectClass) return false;
     if (x.asInstanceOf(y) != null) return true;
     if (y != functionClass) return false;
     return x.callType != null;
   }
 
   /// Return `true` if [x] is a (non-strict) subclass of [y].
   bool isSubclassOf(ClassElement x, ClassElement y) {
     assert(checkInvariants(x));
     assert(checkInvariants(y));
 
     if (y == objectClass) return true;
     if (x == objectClass) return false;
     while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
       if (x == y) return true;
       x = x.superclass;
     }
     return false;
   }
 
-  /// Returns `true` if [cls] is instantiated either directly or through a
-  /// subclass.
+  /// Returns `true` if [cls] is instantiated.
   bool isInstantiated(ClassElement cls) {
     return compiler.resolverWorld.isInstantiated(cls);
   }
 
-  /// Returns `true` if [cls] is implemented by an instantiated class.
-  bool isImplemented(ClassElement cls) {
-    return compiler.resolverWorld.isImplemented(cls);
-  }
-
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     if (hierarchy == null) return const <ClassElement>[];
     return hierarchy.subclasses(
         includeIndirectlyInstantiated: false,
         includeUninstantiated: false);
   }
 
@@ skipping 105 matching lines @@
     Iterable<MixinApplicationElement> uses = _mixinUses[cls];
     return uses != null ? uses : const <MixinApplicationElement>[];
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls) {
     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];
-            if (next != null) {
-              next.forEach(addLiveUse);
-            }
-          }
-        }
-
-        _mixinUses[mixin].forEach(addLiveUse);
-        if (uses.isNotEmpty) {
-          _liveMixinUses[mixin] = uses;
-        }
+        Iterable<MixinApplicationElement> uses =
+            _mixinUses[mixin].where(isInstantiated);
+        if (uses.isNotEmpty) _liveMixinUses[mixin] = uses.toList();
       }
     }
     Iterable<MixinApplicationElement> uses = _liveMixinUses[cls];
     return uses != null ? uses : const <MixinApplicationElement>[];
   }
 
   /// Returns `true` if [cls] is mixed into a live class.
   bool isUsedAsMixin(ClassElement cls) {
     return !mixinUsesOf(cls).isEmpty;
   }
@@ skipping 168 matching lines @@
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
     compiler.resolverWorld.directlyInstantiatedClasses.forEach(addSubtypes);
   }
 
-  @override
-  String dump() {
-    StringBuffer sb = new StringBuffer();
-    sb.write("Instantiated classes in the closed world:\n");
-    getClassHierarchyNode(compiler.objectClass)
-        .printOn(sb, ' ', instantiatedOnly: true);
-    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>());
     users.add(mixinApplication);
   }
@@ skipping 127 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.hasIncrementalSupport;
 }