Compute isSubtype and isSubclass using ClassSet/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;
@@ skipping 210 matching lines @@
   /// This means that [other] is a subclass of [cls].
   bool contains(ClassHierarchyNode other) {
     while (other != null) {
       if (cls == other.cls) return true;
       if (hierarchyDepth >= other.hierarchyDepth) return false;
       other = other.parentNode;
     }
     return false;
   }
 
+  /// Returns `true` if `other.cls` is a subclass of [cls].
+  bool hasSubclass(ClassHierarchyNode other) {
+    return contains(other);
+  }
+
   /// `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<ClassEntity> subclassesByMask(EnumSet<Instantiation> mask,
@@ skipping 232 matching lines @@
   /// 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);
 
   ClassEntity get cls => node.cls;
 
+  /// Returns `true` if `other.cls` is a subclass of [cls].
+  bool hasSubclass(ClassHierarchyNode other) => node.hasSubclass(other);
+
+  /// Returns `true` if `other.cls` is a subtype of [cls].
+  bool hasSubtype(ClassHierarchyNode other) {
+    if (hasSubclass(other)) return true;
+    if (_subtypes != null) {
+      for (ClassHierarchyNode subtypeNode in _subtypes) {
+        if (subtypeNode.hasSubclass(other)) return true;
+      }
+    }
+    return false;
+  }
+
   /// 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 406 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(ClassEntity cls);