Use entity WorldImpl where possible

pkg/compiler/lib/src/universe/class_set.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.world.class_set;
 
 import 'dart:collection' show IterableBase;
 
 import '../elements/elements.dart' show ClassElement;
 import '../elements/entities.dart' show ClassEntity;
 import '../util/enumset.dart' show EnumSet;
 import '../util/util.dart' show Link;
 
 /// Enum for the different kinds of instantiation of a class.
 enum Instantiation {
   UNINSTANTIATED,
   DIRECTLY_INSTANTIATED,
   INDIRECTLY_INSTANTIATED,
   ABSTRACTLY_INSTANTIATED,
 }
 
-/// Node for [cls] in a tree forming the subclass relation of [ClassElement]s.
+/// Node for [cls] in a tree forming the subclass relation of [ClassEntity]s.
 ///
 /// This is used by the [ClosedWorld] to perform queries on subclass and subtype
 /// relations.
 ///
 /// For this class hierarchy:
 ///
 ///     class A {}
 ///     class B extends A {}
 ///     class C extends A {}
 ///     class D extends B {}
@@ skipping 61 matching lines @@
     return mask;
   }
 
   final ClassHierarchyNode parentNode;
   final ClassEntity cls;
   final EnumSet<Instantiation> _mask = new EnumSet<Instantiation>.fromValues(
       const <Instantiation>[Instantiation.UNINSTANTIATED]);
 
   final int hierarchyDepth;
 
-  ClassElement _leastUpperInstantiatedSubclass;
+  ClassEntity _leastUpperInstantiatedSubclass;
   int _instantiatedSubclassCount = 0;
 
   /// `true` if [cls] has been directly instantiated.
   ///
   /// For instance `C` but _not_ `B` in:
   ///   class B {}
   ///   class C extends B {}
   ///   main() => new C();
   ///
   bool get isDirectlyInstantiated =>
@@ skipping 115 matching lines @@
 
   /// `true` if [cls] has been directly, indirectly, or abstractly instantiated.
   bool get isInstantiated =>
       isExplicitlyInstantiated || isIndirectlyInstantiated;
 
   /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
   ///
   /// Subclasses are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subclassesByMask(EnumSet<Instantiation> mask,
+  Iterable<ClassEntity> subclassesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return new ClassHierarchyNodeIterable(this, mask, includeRoot: !strict);
   }
 
   /// Applies [predicate] to each subclass of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subclasses if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
-  bool anySubclass(
-      bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
+  bool anySubclass(bool predicate(ClassEntity cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
-    IterationStep wrapper(ClassElement cls) {
+    IterationStep wrapper(ClassEntity cls) {
       return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
 
     return forEachSubclass(wrapper, mask, strict: strict) == IterationStep.STOP;
   }
 
   /// Applies [f] to each subclass of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subclasses if their instantiation properties intersect
@@ skipping 28 matching lines @@
     }
     if (nextStep == IterationStep.STOP) {
       return nextStep;
     }
     return IterationStep.CONTINUE;
   }
 
   /// Returns the most specific subclass of [cls] (including [cls]) that is
   /// directly instantiated or a superclass of all directly instantiated
   /// subclasses. If [cls] is not instantiated, `null` is returned.
-  ClassElement getLubOfInstantiatedSubclasses() {
+  ClassEntity getLubOfInstantiatedSubclasses() {
     if (!isInstantiated) return null;
     if (_leastUpperInstantiatedSubclass == null) {
       _leastUpperInstantiatedSubclass =
           _computeLeastUpperInstantiatedSubclass();
     }
     return _leastUpperInstantiatedSubclass;
   }
 
-  ClassElement _computeLeastUpperInstantiatedSubclass() {
+  ClassEntity _computeLeastUpperInstantiatedSubclass() {
     if (isExplicitlyInstantiated) {
       return cls;
     }
     if (!isInstantiated) {
       return null;
     }
     ClassHierarchyNode subclass;
     for (Link<ClassHierarchyNode> link = _directSubclasses;
         !link.isEmpty;
         link = link.tail) {
@@ skipping 81 matching lines @@
     StringBuffer sb = new StringBuffer();
     printOn(sb, indentation,
         instantiatedOnly: instantiatedOnly, withRespectTo: withRespectTo);
     return sb.toString();
   }
 
   String toString() => cls.toString();
 }
 
 /// Object holding the subclass and subtype relation for a single
-/// [ClassElement].
+/// [ClassEntity].
 ///
 /// The subclass relation for a class `C` is modelled through a reference to
 /// the [ClassHierarchyNode] for `C` in the global [ClassHierarchyNode] tree
 /// computed in [World].
 ///
 /// The subtype relation for a class `C` is modelled through a collection of
 /// disjoint [ClassHierarchyNode] subtrees. The subclasses of `C`, modelled
 /// through the aforementioned [ClassHierarchyNode] pointer, are extended with
 /// the subtypes that do not extend `C` through a list of additional
 /// [ClassHierarchyNode] nodes. This list is normalized to contain only the
@@ skipping 24 matching lines @@
 /// The subtypes `B` and `E` are not directly modeled because they are implied
 /// by their subclass relation to `A` and `D`, repectively. This can be seen
 /// if we expand the subclass subtrees:
 ///
 ///      A  ->  [C, D, F]
 ///      |          |
 ///      B          E
 ///
 class ClassSet {
   final ClassHierarchyNode node;
-  ClassElement _leastUpperInstantiatedSubtype;
+  ClassEntity _leastUpperInstantiatedSubtype;
 
   /// A list of the class hierarchy nodes for the subtypes that declare a
   /// subtype relationship to [cls] either directly or indirectly.
   ///
   /// For instance
   ///
   ///     class A {}
   ///     class B extends A {}
   ///     class C implements B {}
   ///     class D implements A {}
   ///     class E extends D {}
   ///
   /// The class hierarchy nodes for classes `C` and `D` are in [_subtypes]. `C`
   /// because it implements `A` through `B` and `D` because it implements `A`
   /// directly. `E` also implements `A` through its extension of `D` and it is
   /// therefore included through the class hierarchy node for `D`.
   ///
   List<ClassHierarchyNode> _subtypes;
 
   ClassSet(this.node);
 
-  ClassElement get cls => node.cls;
+  ClassEntity get cls => node.cls;
 
   /// Returns the number of directly instantiated subtypes of [cls].
   int get instantiatedSubtypeCount {
     int count = node.instantiatedSubclassCount;
     if (_subtypes != null) {
       for (ClassHierarchyNode subtypeNode in _subtypes) {
         if (subtypeNode.isExplicitlyInstantiated) {
           count++;
         }
         count += subtypeNode.instantiatedSubclassCount;
@@ skipping 17 matching lines @@
 
   Iterable<ClassHierarchyNode> get subtypeNodes {
     return _subtypes ?? const <ClassHierarchyNode>[];
   }
 
   /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
   ///
   /// Subclasses are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subclassesByMask(EnumSet<Instantiation> mask,
+  Iterable<ClassEntity> subclassesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return node.subclassesByMask(mask, strict: strict);
   }
 
   /// Returns an [Iterable] of the subtypes of [cls] possibly including [cls].
   ///
   /// The directly instantiated, indirectly instantiated and uninstantiated
   /// subtypes of [cls] are returned if [includeDirectlyInstantiated],
   /// [includeIndirectlyInstantiated], and [includeUninstantiated] are `true`,
   /// respectively. If [strict] is `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subtypes(
+  Iterable<ClassEntity> subtypes(
       {bool includeDirectlyInstantiated: true,
       bool includeIndirectlyInstantiated: true,
       bool includeUninstantiated: true,
       bool strict: false}) {
     EnumSet<Instantiation> mask = ClassHierarchyNode.createMask(
         includeDirectlyInstantiated: includeDirectlyInstantiated,
         includeIndirectlyInstantiated: includeIndirectlyInstantiated,
         includeUninstantiated: includeUninstantiated);
     return subtypesByMask(mask, strict: strict);
   }
 
   /// Returns an [Iterable] of the subtypes of [cls] possibly including [cls].
   ///
   /// Subtypes are included if their instantiation properties intersect with
   /// their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [cls] itself is _not_ returned.
-  Iterable<ClassElement> subtypesByMask(EnumSet<Instantiation> mask,
+  Iterable<ClassEntity> subtypesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     if (_subtypes == null) {
       return node.subclassesByMask(mask, strict: strict);
     }
 
     return new SubtypesIterable.SubtypesIterator(this, mask,
         includeRoot: !strict);
   }
 
   /// Applies [predicate] to each subclass of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subclasses if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
-  bool anySubclass(
-      bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
+  bool anySubclass(bool predicate(ClassEntity cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return node.anySubclass(predicate, mask, strict: strict);
   }
 
   /// Applies [f] to each subclass of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subclasses if their instantiation properties intersect
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
@@ skipping 10 matching lines @@
     return node.forEachSubclass(f, mask, strict: strict);
   }
 
   /// Applies [predicate] to each subtype of [cls] matching the criteria
   /// specified by [mask] and [strict]. If [predicate] returns `true` on a
   /// class, visitation is stopped immediately and the function returns `true`.
   ///
   /// [predicate] is applied to subtypes if their instantiation properties
   /// intersect with their corresponding [Instantiation] values in [mask]. If
   /// [strict] is `true`, [predicate] is _not_ called on [cls] itself.
-  bool anySubtype(bool predicate(ClassElement cls), EnumSet<Instantiation> mask,
+  bool anySubtype(bool predicate(ClassEntity cls), EnumSet<Instantiation> mask,
       {bool strict: false}) {
-    IterationStep wrapper(ClassElement cls) {
+    IterationStep wrapper(ClassEntity cls) {
       return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
 
     return forEachSubtype(wrapper, mask, strict: strict) == IterationStep.STOP;
   }
 
   /// Applies [f] to each subtype of [cls] matching the criteria specified by
   /// [mask] and [strict].
   ///
   /// [f] is a applied to subtypes if their instantiation properties intersect
@@ skipping 69 matching lines @@
       if (!added) {
         newSubtypes.add(subtype);
       }
       _subtypes = newSubtypes;
     }
   }
 
   /// Returns the most specific subtype of [cls] (including [cls]) that is
   /// directly instantiated or a superclass of all directly instantiated
   /// subtypes. If no subtypes of [cls] are instantiated, `null` is returned.
-  ClassElement getLubOfInstantiatedSubtypes() {
+  ClassEntity getLubOfInstantiatedSubtypes() {
     if (_leastUpperInstantiatedSubtype == null) {
       _leastUpperInstantiatedSubtype = _computeLeastUpperInstantiatedSubtype();
     }
     return _leastUpperInstantiatedSubtype;
   }
 
-  ClassElement _computeLeastUpperInstantiatedSubtype() {
+  ClassEntity _computeLeastUpperInstantiatedSubtype() {
     if (node.isExplicitlyInstantiated) {
       return cls;
     }
     if (_subtypes == null) {
       return node.getLubOfInstantiatedSubclasses();
     }
     ClassHierarchyNode subtype;
     if (node.isInstantiated) {
       subtype = node;
     }
@@ skipping 22 matching lines @@
         node.printOn(sb, '  ');
         sb.write('\n');
       }
     }
     sb.write(']');
     return sb.toString();
   }
 }
 
 /// Iterable for subclasses of a [ClassHierarchyNode].
-class ClassHierarchyNodeIterable extends IterableBase<ClassElement> {
+class ClassHierarchyNodeIterable extends IterableBase<ClassEntity> {
   final ClassHierarchyNode root;
   final EnumSet<Instantiation> mask;
   final bool includeRoot;
 
   ClassHierarchyNodeIterable(this.root, this.mask, {this.includeRoot: true}) {
     if (root == null) throw new StateError("No root for iterable.");
   }
 
   @override
-  Iterator<ClassElement> get iterator {
+  Iterator<ClassEntity> get iterator {
     return new ClassHierarchyNodeIterator(this);
   }
 }
 
 /// Iterator for subclasses of a [ClassHierarchyNode].
 ///
 /// Classes are returned in pre-order DFS fashion.
-class ClassHierarchyNodeIterator implements Iterator<ClassElement> {
+class ClassHierarchyNodeIterator implements Iterator<ClassEntity> {
   final ClassHierarchyNodeIterable iterable;
 
   /// The class node holding the [current] class.
   ///
   /// This is `null` before the first call to [moveNext] and at the end of
   /// iteration, i.e. after [moveNext] has returned `false`.
   ClassHierarchyNode currentNode;
 
   /// Stack of pending class nodes.
   ///
   /// This is `null` before the first call to [moveNext].
   Link<ClassHierarchyNode> stack;
 
   ClassHierarchyNodeIterator(this.iterable);
 
   ClassHierarchyNode get root => iterable.root;
 
   bool get includeRoot => iterable.includeRoot;
 
   EnumSet<Instantiation> get mask => iterable.mask;
 
   bool get includeUninstantiated {
     return mask.contains(Instantiation.UNINSTANTIATED);
   }
 
   @override
-  ClassElement get current {
+  ClassEntity get current {
     return currentNode != null ? currentNode.cls : null;
   }
 
   @override
   bool moveNext() {
     if (stack == null) {
       // First call to moveNext
       stack = const Link<ClassHierarchyNode>().prepend(root);
       return _findNext();
     } else {
@@ skipping 31 matching lines @@
   }
 
   /// Returns `true` if the class of [node] is a valid result for this iterator.
   bool _isValid(ClassHierarchyNode node) {
     if (!includeRoot && node == root) return false;
     return mask.intersects(node._mask);
   }
 }
 
 /// Iterable for the subtypes in a [ClassSet].
-class SubtypesIterable extends IterableBase<ClassElement> {
+class SubtypesIterable extends IterableBase<ClassEntity> {
   final ClassSet subtypeSet;
   final EnumSet<Instantiation> mask;
   final bool includeRoot;
 
   SubtypesIterable.SubtypesIterator(this.subtypeSet, this.mask,
       {this.includeRoot: true});
 
   @override
-  Iterator<ClassElement> get iterator => new SubtypesIterator(this);
+  Iterator<ClassEntity> get iterator => new SubtypesIterator(this);
 }
 
 /// Iterator for the subtypes in a [ClassSet].
-class SubtypesIterator extends Iterator<ClassElement> {
+class SubtypesIterator extends Iterator<ClassEntity> {
   final SubtypesIterable iterable;
-  Iterator<ClassElement> elements;
+  Iterator<ClassEntity> elements;
   Iterator<ClassHierarchyNode> hierarchyNodes;
 
   SubtypesIterator(this.iterable);
 
   bool get includeRoot => iterable.includeRoot;
 
   EnumSet<Instantiation> get mask => iterable.mask;
 
   @override
-  ClassElement get current {
+  ClassEntity get current {
     if (elements != null) {
       return elements.current;
     }
     return null;
   }
 
   @override
   bool moveNext() {
     if (elements == null && hierarchyNodes == null) {
       // Initial state. Iterate through subclasses.
@@ skipping 28 matching lines @@
   /// Iteration stops immediately.
   STOP,
 
   /// Iteration skips the subclasses of the current class.
   SKIP_SUBCLASSES,
 }
 
 /// Visiting function used for the `forEachX` functions of [ClassHierarchyNode]
 /// and [ClassSet]. The return value controls the continued iteration. If `null`
 /// is returned, iteration continues to the end.
-typedef IterationStep ForEachFunction(ClassElement cls);
+typedef IterationStep ForEachFunction(ClassEntity cls);