Add EnumSet.

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 '../util/util.dart' show Link;
+import 'dart:collection' show
+    IterableBase;
+import '../elements/elements.dart' show
+    ClassElement;
+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,
+}
 
 /// Node for [cls] in a tree forming the subclass relation of [ClassElement]s.
 ///
 /// This is used by the [ClassWorld] 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 {}
 ///     class E extends D {}
 ///
 /// the [ClassHierarchyNode]s form this subclass tree:
 ///
 ///       Object
 ///         |
 ///         A
 ///        / \
 ///       B   C
 ///       |
 ///       D
 ///       |
 ///       E
 ///
 class ClassHierarchyNode {
+  /// Enum set for selecting instantiated classes in
+  /// [ClassHierarchyNode.subclassesByMask],
+  /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
+  static final EnumSet<Instantiation> INSTANTIATED =
+      new EnumSet<Instantiation>.fromValues(
+          const <Instantiation>[
+              Instantiation.DIRECTLY_INSTANTIATED,
+              Instantiation.INDIRECTLY_INSTANTIATED],
+          fixed: true);
+
+  /// Enum set for selecting directly instantiated classes in
+  /// [ClassHierarchyNode.subclassesByMask],
+  /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
+  static final EnumSet<Instantiation> DIRECTLY_INSTANTIATED =
+      new EnumSet<Instantiation>.fromValues(
+          const <Instantiation>[Instantiation.DIRECTLY_INSTANTIATED],
+          fixed: true);
+
+  /// Enum set for selecting all classes in
+  /// [ClassHierarchyNode.subclassesByMask],
+  /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
+  static final EnumSet<Instantiation> ALL =
+      new EnumSet<Instantiation>.fromValues(
+          Instantiation.values,
+          fixed: true);
+
+  /// Creates an enum set for selecting the returned classes in
+  /// [ClassHierarchyNode.subclassesByMask],
+  /// [ClassHierarchyNode.subclassesByMask] and [ClassSet.subtypesByMask].
+  static EnumSet<Instantiation> createMask(
+      {bool includeDirectlyInstantiated: true,
+       bool includeIndirectlyInstantiated: true,
+       bool includeUninstantiated: true}) {
+    EnumSet<Instantiation> mask = new EnumSet<Instantiation>();
+    if (includeDirectlyInstantiated) {
+      mask.add(Instantiation.DIRECTLY_INSTANTIATED);
+    }
+    if (includeIndirectlyInstantiated) {
+      mask.add(Instantiation.INDIRECTLY_INSTANTIATED);
+    }
+    if (includeUninstantiated) {
+      mask.add(Instantiation.UNINSTANTIATED);
+    }
+    return mask;
+  }
+
   final ClassElement cls;
+  final EnumSet<Instantiation> _mask =
+      new EnumSet<Instantiation>.fromValues(
+          const <Instantiation>[Instantiation.UNINSTANTIATED]);
+
   ClassElement _leastUpperInstantiatedSubclass;
 
   /// `true` if [cls] has been directly instantiated.
   ///
   /// For instance `C` but _not_ `B` in:
   ///   class B {}
   ///   class C extends B {}
   ///   main() => new C();
   ///
-  bool isDirectlyInstantiated = false;
+  bool get isDirectlyInstantiated =>
+      _mask.contains(Instantiation.DIRECTLY_INSTANTIATED);
+
+  void set isDirectlyInstantiated(bool value) {
+    if (value != isDirectlyInstantiated) {
+      if (value) {
+        _mask.remove(Instantiation.UNINSTANTIATED);
+        _mask.add(Instantiation.DIRECTLY_INSTANTIATED);
+      } else {
+        _mask.remove(Instantiation.DIRECTLY_INSTANTIATED);
+        if (_mask.isEmpty) {
+          _mask.add(Instantiation.UNINSTANTIATED);
+        }
+      }
+    }
+  }
 
   /// `true` if [cls] has been instantiated through subclasses.
   ///
   /// For instance `A` and `B` but _not_ `C` in:
   ///   class A {}
   ///   class B extends A {}
   ///   class C extends B {}
   ///   main() => [new B(), new C()];
   ///
-  bool isIndirectlyInstantiated = false;
+  bool get isIndirectlyInstantiated =>
+      _mask.contains(Instantiation.INDIRECTLY_INSTANTIATED);
+
+  void set isIndirectlyInstantiated(bool value) {
+    if (value != isIndirectlyInstantiated) {
+      if (value) {
+        _mask.remove(Instantiation.UNINSTANTIATED);
+        _mask.add(Instantiation.INDIRECTLY_INSTANTIATED);
+      } else {
+        _mask.remove(Instantiation.INDIRECTLY_INSTANTIATED);
+        if (_mask.isEmpty) {
+          _mask.add(Instantiation.UNINSTANTIATED);
+        }
+      }
+    }
+  }
 
   /// The nodes for the direct subclasses of [cls].
   Link<ClassHierarchyNode> _directSubclasses = const Link<ClassHierarchyNode>();
 
   ClassHierarchyNode(this.cls);
 
   /// Adds [subclass] as a direct subclass of [cls].
   void addDirectSubclass(ClassHierarchyNode subclass) {
     assert(subclass.cls.superclass == cls);
     assert(!_directSubclasses.contains(subclass));
@@ skipping 19 matching lines @@
   ///
   /// The directly instantiated, indirectly instantiated and uninstantiated
   /// subclasses of [cls] are returned if [includeDirectlyInstantiated],
   /// [includeIndirectlyInstantiated], and [includeUninstantiated] are `true`,
   /// respectively. If [strict] is `true`, [cls] itself is _not_ returned.
   Iterable<ClassElement> subclasses(
       {bool includeDirectlyInstantiated: true,
        bool includeIndirectlyInstantiated: true,
        bool includeUninstantiated: true,
        bool strict: false}) {
+    EnumSet<Instantiation> mask = createMask(
+        includeDirectlyInstantiated: includeDirectlyInstantiated,
+        includeIndirectlyInstantiated:includeIndirectlyInstantiated,
+        includeUninstantiated: includeUninstantiated);
+    return subclassesByMask(mask, strict: strict);
+  }
+
+  /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
+  ///
+  /// The [mask] defines the included subset of the subclasses based on their
+  /// instantiation properties. If [strict] is `true`, [cls] itself is _not_
+  /// returned.
+  Iterable<ClassElement> subclassesByMask(
+      EnumSet<Instantiation> mask,
+      {bool strict: false}) {
     return new ClassHierarchyNodeIterable(
-        this,
-        includeRoot: !strict,
-        includeDirectlyInstantiated: includeDirectlyInstantiated,
-        includeIndirectlyInstantiated: includeIndirectlyInstantiated,
-        includeUninstantiated: includeUninstantiated);
+        this, mask, includeRoot: !strict);
   }
 
   /// 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 155 matching lines @@
   ///
   /// The directly instantiated, indirectly instantiated and uninstantiated
   /// subclasses of [cls] are returned if [includeDirectlyInstantiated],
   /// [includeIndirectlyInstantiated], and [includeUninstantiated] are `true`,
   /// respectively. If [strict] is `true`, [cls] itself is _not_ returned.
   Iterable<ClassElement> subclasses(
       {bool includeDirectlyInstantiated: true,
        bool includeIndirectlyInstantiated: true,
        bool includeUninstantiated: true,
        bool strict: false}) {
-    return node.subclasses(
-        strict: strict,
+    EnumSet<Instantiation> mask = ClassHierarchyNode.createMask(
         includeDirectlyInstantiated: includeDirectlyInstantiated,
-        includeIndirectlyInstantiated: includeIndirectlyInstantiated,
+        includeIndirectlyInstantiated:includeIndirectlyInstantiated,
         includeUninstantiated: includeUninstantiated);
+    return subclassesByMask(mask, strict: strict);
+  }
+
+  /// Returns an [Iterable] of the subclasses of [cls] possibly including [cls].
+  ///
+  /// The [mask] defines the included subset of the subclasses based on their
+  /// instantiation properties. If [strict] is `true`, [cls] itself is _not_
+  /// returned.
+  Iterable<ClassElement> 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(
       {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].
+  ///
+  /// The [mask] defines the included subset of the subtypes based on their

[sigurdm, 2016/01/11 08:48:55]

It is not clear from the description of `mask` that we accept all subtypes with
an *intersecting* mask.

[Johnni Winther, 2016/01/22 11:54:13]

Updated the comments.

+  /// instantiation properties. If [strict] is `true`, [cls] itself is _not_
+  /// returned.
+  Iterable<ClassElement> subtypesByMask(
+      EnumSet<Instantiation> mask,
+      {bool strict: false}) {
     if (_directSubtypes == null) {
-      return node.subclasses(
-          strict: strict,
-          includeDirectlyInstantiated: includeDirectlyInstantiated,
-          includeIndirectlyInstantiated: includeIndirectlyInstantiated,
-          includeUninstantiated: includeUninstantiated);
+      return node.subclassesByMask(
+          mask,
+          strict: strict);
     }
+
     return new SubtypesIterable.SubtypesIterator(this,
-        includeRoot: !strict,
-        includeDirectlyInstantiated: includeDirectlyInstantiated,
-        includeIndirectlyInstantiated: includeIndirectlyInstantiated,
-        includeUninstantiated: includeUninstantiated);
+        mask,
+        includeRoot: !strict);
   }
 
   /// Adds [subtype] as a subtype of [cls].
   void addSubtype(ClassHierarchyNode subtype) {
     if (node.contains(subtype.cls)) {
       return;
     }
     if (_directSubtypes == null) {
       _directSubtypes = <ClassHierarchyNode>[subtype];
     } else {
@@ skipping 87 matching lines @@
       }
     }
     sb.write(']');
     return sb.toString();
   }
 }
 
 /// Iterable for subclasses of a [ClassHierarchyNode].
 class ClassHierarchyNodeIterable extends IterableBase<ClassElement> {
   final ClassHierarchyNode root;
+  final EnumSet<Instantiation> mask;
   final bool includeRoot;
-  final bool includeDirectlyInstantiated;
-  final bool includeIndirectlyInstantiated;
-  final bool includeUninstantiated;
 
   ClassHierarchyNodeIterable(
       this.root,
-      {this.includeRoot: true,
-       this.includeDirectlyInstantiated: true,
-       this.includeIndirectlyInstantiated: true,
-       this.includeUninstantiated: true}) {
+      this.mask,
+      {this.includeRoot: true}) {
     if (root == null) throw new StateError("No root for iterable.");
   }
 
   @override
   Iterator<ClassElement> get iterator {
     return new ClassHierarchyNodeIterator(this);
   }
 }
 
 /// Iterator for subclasses of a [ClassHierarchyNode].
@@ skipping 12 matching lines @@
   ///
   /// 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;
 
-  bool get includeDirectlyInstantiated => iterable.includeDirectlyInstantiated;
+  EnumSet<Instantiation> get mask => iterable.mask;
 
-  bool get includeIndirectlyInstantiated {
-    return iterable.includeIndirectlyInstantiated;
+  bool get includeUninstantiated {
+    return mask.contains(Instantiation.UNINSTANTIATED);
   }
 
-  bool get includeUninstantiated => iterable.includeUninstantiated;
-
   @override
   ClassElement get current {
     return currentNode != null ? currentNode.cls : null;
   }
 
   @override
   bool moveNext() {
     if (stack == null) {
       // First call to moveNext
       stack = const Link<ClassHierarchyNode>().prepend(root);
@@ skipping 28 matching lines @@
       }
       if (_isValid(currentNode)) {
         return true;
       }
     }
   }
 
   /// Returns `true` if the class of [node] is a valid result for this iterator.
   bool _isValid(ClassHierarchyNode node) {
     if (!includeRoot && node == root) return false;
-    if (includeDirectlyInstantiated && node.isDirectlyInstantiated) {
-      return true;
-    }
-    if (includeIndirectlyInstantiated && node.isIndirectlyInstantiated) {
-      return true;
-    }
-    if (includeUninstantiated && !node.isInstantiated) {
-      return true;
-    }
-    return false;
+    return mask.intersects(node._mask);
   }
 }
 
 /// Iterable for the subtypes in a [ClassSet].
 class SubtypesIterable extends IterableBase<ClassElement> {
   final ClassSet subtypeSet;
+  final EnumSet<Instantiation> mask;
   final bool includeRoot;
-  final bool includeDirectlyInstantiated;
-  final bool includeIndirectlyInstantiated;
-  final bool includeUninstantiated;
 
   SubtypesIterable.SubtypesIterator(
       this.subtypeSet,
-      {this.includeRoot: true,
-       this.includeDirectlyInstantiated: true,
-       this.includeIndirectlyInstantiated: true,
-       this.includeUninstantiated: true});
+      this.mask,
+      {this.includeRoot: true});
 
   @override
   Iterator<ClassElement> get iterator => new SubtypesIterator(this);
 }
 
 /// Iterator for the subtypes in a [ClassSet].
 class SubtypesIterator extends Iterator<ClassElement> {
   final SubtypesIterable iterable;
   Iterator<ClassElement> elements;
   Iterator<ClassHierarchyNode> hierarchyNodes;
 
   SubtypesIterator(this.iterable);
 
   bool get includeRoot => iterable.includeRoot;
 
-  bool get includeDirectlyInstantiated => iterable.includeDirectlyInstantiated;
-
-  bool get includeIndirectlyInstantiated {
-    return iterable.includeIndirectlyInstantiated;
-  }
-
-  bool get includeUninstantiated => iterable.includeUninstantiated;
+  EnumSet<Instantiation> get mask => iterable.mask;
 
   @override
   ClassElement get current {
     if (elements != null) {
       return elements.current;
     }
     return null;
   }
 
   @override
   bool moveNext() {
     if (elements == null && hierarchyNodes == null) {
       // Initial state. Iterate through subclasses.
-      elements = iterable.subtypeSet.node.subclasses(
-          strict: !includeRoot,
-          includeDirectlyInstantiated: includeDirectlyInstantiated,
-          includeIndirectlyInstantiated: includeIndirectlyInstantiated,
-          includeUninstantiated: includeUninstantiated).iterator;
+      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;
     }
     while (hierarchyNodes.moveNext()) {
-      elements = hierarchyNodes.current.subclasses(
-          includeDirectlyInstantiated: includeDirectlyInstantiated,
-          includeIndirectlyInstantiated: includeIndirectlyInstantiated,
-          includeUninstantiated: includeUninstantiated).iterator;
+      elements = hierarchyNodes.current.subclassesByMask(mask).iterator;
       if (elements.moveNext()) {
         return true;
       }
     }
     return false;
   }
 }