Use ClassEntity in ClassHierarchyNode

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,
 }
@@ skipping 67 matching lines @@
     if (includeUninstantiated) {
       mask.add(Instantiation.UNINSTANTIATED);
     }
     if (includeAbstractlyInstantiated) {
       mask.add(Instantiation.ABSTRACTLY_INSTANTIATED);
     }
     return mask;
   }
 
   final ClassHierarchyNode parentNode;
-  final ClassElement cls;
+  final ClassEntity cls;
   final EnumSet<Instantiation> _mask = new EnumSet<Instantiation>.fromValues(
       const <Instantiation>[Instantiation.UNINSTANTIATED]);
 
+  final int hierarchyDepth;
+
   ClassElement _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();
   ///
@@ skipping 81 matching lines @@
         if (_mask.isEmpty) {
           _mask.add(Instantiation.UNINSTANTIATED);
         }
       }
     }
   }
 
   /// The nodes for the direct subclasses of [cls].
   Link<ClassHierarchyNode> _directSubclasses = const Link<ClassHierarchyNode>();
 
-  ClassHierarchyNode(this.parentNode, this.cls) {
+  ClassHierarchyNode(this.parentNode, this.cls, this.hierarchyDepth) {

[Emily Fortuna, 2017/04/11 19:45:48]

why not make a getter for hierarchyDepth:

int get hierarchyDepth => cls.hierarchyDepth;

rather than needing to pass in more information to the constructor?

[Johnni Winther, 2017/04/12 07:19:28]

Because ClassEntity doesn't have a .hierarchyDepth and I'm reluctant to add it.
This is part of avoiding the need for it.

     if (parentNode != null) {
       parentNode.addDirectSubclass(this);
     }
   }
 
   /// Adds [subclass] as a direct subclass of [cls].
   void addDirectSubclass(ClassHierarchyNode subclass) {
-    assert(subclass.cls.superclass == cls);
     assert(!_directSubclasses.contains(subclass));
     _directSubclasses = _directSubclasses.prepend(subclass);
   }
 
   Iterable<ClassHierarchyNode> get directSubclasses => _directSubclasses;
 
   /// Returns `true` if [other] is contained in the subtree of this node.
   ///
   /// This means that [other] is a subclass of [cls].
-  bool contains(ClassElement other) {
+  bool contains(ClassHierarchyNode other) {
     while (other != null) {
-      if (cls == other) return true;
-      if (cls.hierarchyDepth >= other.hierarchyDepth) return false;
-      other = other.superclass;
+      if (cls == other.cls) return true;
+      if (hierarchyDepth >= other.hierarchyDepth) return false;
+      other = other.parentNode;
     }
     return false;
   }
 
   /// `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].
   ///
@@ skipping 391 matching lines @@
           return subForEach;
         }
       }
     }
     assert(nextStep != IterationStep.SKIP_SUBCLASSES);
     return nextStep;
   }
 
   /// Adds [subtype] as a subtype of [cls].
   void addSubtype(ClassHierarchyNode subtype) {
-    if (node.contains(subtype.cls)) {
+    if (node.contains(subtype)) {
       return;
     }
     if (_subtypes == null) {
       _subtypes = <ClassHierarchyNode>[subtype];
     } else {
-      int hierarchyDepth = subtype.cls.hierarchyDepth;
+      int hierarchyDepth = subtype.hierarchyDepth;
       List<ClassHierarchyNode> newSubtypes = <ClassHierarchyNode>[];
       bool added = false;
       for (ClassHierarchyNode otherSubtype in _subtypes) {
-        int otherHierarchyDepth = otherSubtype.cls.hierarchyDepth;
+        int otherHierarchyDepth = otherSubtype.hierarchyDepth;
         if (hierarchyDepth == otherHierarchyDepth) {
           if (subtype == otherSubtype) {
             return;
           } else {
             // [otherSubtype] is unrelated to [subtype].
             newSubtypes.add(otherSubtype);
           }
-        } else if (hierarchyDepth > otherSubtype.cls.hierarchyDepth) {
+        } else if (hierarchyDepth > otherSubtype.hierarchyDepth) {
           // [otherSubtype] could be a superclass of [subtype].
-          if (otherSubtype.contains(subtype.cls)) {
+          if (otherSubtype.contains(subtype)) {
             // [subtype] is already in this set.
             return;
           } else {
             // [otherSubtype] is unrelated to [subtype].
             newSubtypes.add(otherSubtype);
           }
         } else {
           if (!added) {
             // Insert [subtype] before other subtypes of higher hierarchy depth.
             newSubtypes.add(subtype);
             added = true;
           }
           // [subtype] could be a superclass of [otherSubtype].
-          if (subtype.contains(otherSubtype.cls)) {
+          if (subtype.contains(otherSubtype)) {
             // Replace [otherSubtype].
           } else {
             newSubtypes.add(otherSubtype);
           }
         }
       }
       if (!added) {
         newSubtypes.add(subtype);
       }
       _subtypes = newSubtypes;
@@ skipping 218 matching lines @@
   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);