Updates from comments.

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 '../common.dart';
 import '../elements/elements.dart' show
@@ skipping 203 matching lines @@
   /// 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 strict: false}) {
 
-    ForEach wrapper(ClassElement cls) {
-      return predicate(cls) ? ForEach.STOP : ForEach.CONTINUE;
+    IterationStep wrapper(ClassElement cls) {
+      return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
-    return forEachSubclass(wrapper, mask, strict: strict) == ForEach.STOP;
+    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
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subclasses can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  ForEach forEachSubclass(
+  IterationStep forEachSubclass(
       ForEachFunction f,
       EnumSet<Instantiation> mask,
       {bool strict: false}) {
-    ForEach forEach;
+    IterationStep nextStep;
     if (!strict && mask.intersects(_mask)) {
-      forEach = f(cls);
+      nextStep = f(cls);
     }
     // Interpret `forEach == null` as `forEach == ForEach.CONTINUE`.
-    forEach ??= ForEach.CONTINUE;
+    nextStep ??= IterationStep.CONTINUE;
 
-    if (forEach == ForEach.CONTINUE) {
+    if (nextStep == IterationStep.CONTINUE) {
       if (mask.contains(Instantiation.UNINSTANTIATED) || isInstantiated) {
         for (ClassHierarchyNode subclass in _directSubclasses) {
-          ForEach subForEach = subclass.forEachSubclass(f, mask);
-          if (subForEach == ForEach.STOP) {
+          IterationStep subForEach = subclass.forEachSubclass(f, mask);
+          if (subForEach == IterationStep.STOP) {
             return subForEach;
           }
         }
       }
     }
-    if (forEach == ForEach.STOP) {
-      return forEach;
+    if (nextStep == IterationStep.STOP) {
+      return nextStep;
     }
-    return ForEach.CONTINUE;
+    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() {
     if (!isInstantiated) return null;
     if (_leastUpperInstantiatedSubclass == null) {
       _leastUpperInstantiatedSubclass =
           _computeLeastUpperInstantiatedSubclass();
@@ skipping 139 matching lines @@
 /// if we expand the subclass subtrees:
 ///
 ///      A  ->  [C, D, F]
 ///      |          |
 ///      B          E
 ///
 class ClassSet {
   final ClassHierarchyNode node;
   ClassElement _leastUpperInstantiatedSubtype;
 
-  List<ClassHierarchyNode> _directSubtypes;
+  /// 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;
 
   /// Returns the number of directly instantiated subtypes of [cls].
   int get instantiatedSubtypeCount {
     int count = node.instantiatedSubclassCount;
-    if (_directSubtypes != null) {
-      for (ClassHierarchyNode subtypeNode in _directSubtypes) {
+    if (_subtypes != null) {
+      for (ClassHierarchyNode subtypeNode in _subtypes) {
         if (subtypeNode.isDirectlyInstantiated) {
           count++;
         }
         count += subtypeNode.instantiatedSubclassCount;
       }
     }
     return count;
   }
 
   /// Returns `true` if all instantiated subtypes of [cls] are subclasses of
   /// [cls].
   bool get hasOnlyInstantiatedSubclasses {
-    if (_directSubtypes != null) {
-      for (ClassHierarchyNode subtypeNode in _directSubtypes) {
+    if (_subtypes != null) {
+      for (ClassHierarchyNode subtypeNode in _subtypes) {
         if (subtypeNode.isInstantiated) {
           return false;
         }
       }
     }
     return true;
   }
 
   /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
   ///
@@ skipping 25 matching lines @@
   }
 
   /// 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,
       {bool strict: false}) {
-    if (_directSubtypes == null) {
+    if (_subtypes == null) {
       return node.subclassesByMask(
           mask,
           strict: strict);
     }
 
     return new SubtypesIterable.SubtypesIterator(this,
         mask,
         includeRoot: !strict);
   }
 
@@ skipping 18 matching lines @@
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subclasses can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  ForEach forEachSubclass(
+  IterationStep forEachSubclass(
       ForEachFunction f,
       EnumSet<Instantiation> mask,
       {bool strict: false}) {
     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 strict: false}) {
 
-    ForEach wrapper(ClassElement cls) {
-      return predicate(cls) ? ForEach.STOP : ForEach.CONTINUE;
+    IterationStep wrapper(ClassElement cls) {
+      return predicate(cls) ? IterationStep.STOP : IterationStep.CONTINUE;
     }
-    return forEachSubtype(wrapper, mask, strict: strict) == ForEach.STOP;
+    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
   /// with their corresponding [Instantiation] values in [mask]. If [strict] is
   /// `true`, [f] is _not_ called on [cls] itself.
   ///
   /// The visitation of subtypes can be cut short by the return value of [f].
   /// If [ForEach.STOP] is returned, no further classes are visited and the
   /// function stops immediately. If [ForEach.SKIP_SUBCLASSES] is returned, the
   /// subclasses of the last visited class are skipped, but visitation
   /// continues. The return value of the function is either [ForEach.STOP], if
   /// visitation was stopped, or [ForEach.CONTINUE] if visitation continued to
   /// the end.
-  ForEach forEachSubtype(
+  IterationStep forEachSubtype(
       ForEachFunction f,
       EnumSet<Instantiation> mask,
       {bool strict: false}) {
-    ForEach forEach = node.forEachSubclass(f, mask, strict: strict);
-    forEach ??= ForEach.CONTINUE;
-    if (forEach == ForEach.CONTINUE && _directSubtypes != null) {
-      for (ClassHierarchyNode subclass in _directSubtypes) {
-        ForEach subForEach = subclass.forEachSubclass(f, mask);
-        if (subForEach == ForEach.STOP) {
+    IterationStep nextStep =
+        node.forEachSubclass(f, mask, strict: strict) ?? IterationStep.CONTINUE;
+    if (nextStep == IterationStep.CONTINUE && _subtypes != null) {
+      for (ClassHierarchyNode subclass in _subtypes) {
+        IterationStep subForEach = subclass.forEachSubclass(f, mask);
+        if (subForEach == IterationStep.STOP) {
           return subForEach;
         }
       }
     }
-    assert(forEach != ForEach.SKIP_SUBCLASSES);
-    return forEach;
+    assert(nextStep != IterationStep.SKIP_SUBCLASSES);
+    return nextStep;
   }
 
   /// Adds [subtype] as a subtype of [cls].
   void addSubtype(ClassHierarchyNode subtype) {
     if (node.contains(subtype.cls)) {
       return;
     }
-    if (_directSubtypes == null) {
-      _directSubtypes = <ClassHierarchyNode>[subtype];
+    if (_subtypes == null) {
+      _subtypes = <ClassHierarchyNode>[subtype];
     } else {
       int hierarchyDepth = subtype.cls.hierarchyDepth;
       List<ClassHierarchyNode> newSubtypes = <ClassHierarchyNode>[];
       bool added = false;
-      for (ClassHierarchyNode otherSubtype in _directSubtypes) {
+      for (ClassHierarchyNode otherSubtype in _subtypes) {
         int otherHierarchyDepth = otherSubtype.cls.hierarchyDepth;
         if (hierarchyDepth == otherHierarchyDepth) {
           if (subtype == otherSubtype) {
             return;
           } else {
             // [otherSubtype] is unrelated to [subtype].
             newSubtypes.add(otherSubtype);
           }
         } else if (hierarchyDepth > otherSubtype.cls.hierarchyDepth) {
           // [otherSubtype] could be a superclass of [subtype].
@@ skipping 14 matching lines @@
           if (subtype.contains(otherSubtype.cls)) {
             // Replace [otherSubtype].
           } else {
             newSubtypes.add(otherSubtype);
           }
         }
       }
       if (!added) {
         newSubtypes.add(subtype);
       }
-      _directSubtypes = newSubtypes;
+      _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() {
     if (_leastUpperInstantiatedSubtype == null) {
       _leastUpperInstantiatedSubtype = _computeLeastUpperInstantiatedSubtype();
     }
     return _leastUpperInstantiatedSubtype;
   }
 
   ClassElement _computeLeastUpperInstantiatedSubtype() {
     if (node.isDirectlyInstantiated) {
       return cls;
     }
-    if (_directSubtypes == null) {
+    if (_subtypes == null) {
       return node.getLubOfInstantiatedSubclasses();
     }
     ClassHierarchyNode subtype;
     if (node.isInstantiated) {
       subtype = node;
     }
-    for (ClassHierarchyNode subnode in _directSubtypes) {
+    for (ClassHierarchyNode subnode in _subtypes) {
       if (subnode.isInstantiated) {
         if (subtype == null) {
           subtype = subnode;
         } else {
           return cls;
         }
       }
     }
     if (subtype != null) {
       return subtype.getLubOfInstantiatedSubclasses();
     }
     return null;
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('[\n');
     node.printOn(sb, '  ');
     sb.write('\n');
-    if (_directSubtypes != null) {
-      for (ClassHierarchyNode node in _directSubtypes) {
+    if (_subtypes != null) {
+      for (ClassHierarchyNode node in _subtypes) {
         node.printOn(sb, '  ');
         sb.write('\n');
       }
     }
     sb.write(']');
     return sb.toString();
   }
 }
 
 /// Iterable for subclasses of a [ClassHierarchyNode].
@@ skipping 137 matching lines @@
       // Initial state. Iterate through subclasses.
       elements = iterable.subtypeSet.node.subclassesByMask(
           mask,
           strict: !includeRoot).iterator;
     }
     if (elements != null && elements.moveNext()) {
       return true;
     }
     if (hierarchyNodes == null) {
       // Start iterating through subtypes.
-      hierarchyNodes = iterable.subtypeSet._directSubtypes.iterator;
+      hierarchyNodes = iterable.subtypeSet._subtypes.iterator;
     }
     while (hierarchyNodes.moveNext()) {
       elements = hierarchyNodes.current.subclassesByMask(mask).iterator;
       if (elements.moveNext()) {
         return true;
       }
     }
     return false;
   }
 }
 
 /// Enum values returned from the [ForEachFunction] provided to the `forEachX`
 /// functions of [ClassHierarchyNode] and [ClassSet]. The value is used to
 /// control the continued iteration.
-enum ForEach {
+enum IterationStep {
   /// Iteration continues.
   CONTINUE,
   /// 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 ForEach ForEachFunction(ClassElement cls);
+typedef IterationStep ForEachFunction(ClassElement cls);