Add EnumSet.

pkg/compiler/lib/src/world.dart

 // Copyright (c) 2012, 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;
 
 import 'closure.dart' show
     SynthesizedCallMethodElementX;
 import 'common.dart';
 import 'common/backend_api.dart' show
@@ skipping 217 matching lines @@
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassElement cls) {
     return compiler.resolverWorld.isImplemented(cls);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     if (hierarchy == null) return const <ClassElement>[];
-    return hierarchy.subclasses(
-        includeIndirectlyInstantiated: false,
-        includeUninstantiated: false);
+    return hierarchy.subclassesByMask(
+        ClassHierarchyNode.DIRECTLY_INSTANTIATED);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] _not_ including [cls] itself.
   Iterable<ClassElement> strictSubclassesOf(ClassElement cls) {
     ClassHierarchyNode subclasses = _classHierarchyNodes[cls.declaration];
     if (subclasses == null) return const <ClassElement>[];
-    return subclasses.subclasses(
-        strict: true,
-        includeIndirectlyInstantiated: false,
-        includeUninstantiated: false);
+    return subclasses.subclassesByMask(
+        ClassHierarchyNode.DIRECTLY_INSTANTIATED, strict: true);
   }
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subtypesOf(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       return const <ClassElement>[];
     } else {
-      return classSet.subtypes(
-          includeIndirectlyInstantiated: false,
-          includeUninstantiated: false);
+      return classSet.subtypesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED);
     }
   }
 
   /// Returns an iterable over the directly instantiated that implement [cls]
   /// _not_ including [cls].
   Iterable<ClassElement> strictSubtypesOf(ClassElement cls) {
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       return const <ClassElement>[];
     } else {
-      return classSet.subtypes(
-          strict: true,
-          includeIndirectlyInstantiated: false,
-          includeUninstantiated: false);
+      return classSet.subtypesByMask(
+          ClassHierarchyNode.DIRECTLY_INSTANTIATED,
+          strict: true);
     }
   }
 
   /// Returns `true` if [a] and [b] have any known common subtypes.
   bool haveAnyCommonSubtypes(ClassElement a, ClassElement b) {
     ClassSet classSetA = _classSets[a.declaration];
     ClassSet classSetB = _classSets[b.declaration];
     if (classSetA == null || classSetB == null) return false;
     // TODO(johnniwinther): Implement an optimized query on [ClassSet].
     Set<ClassElement> subtypesOfB = classSetB.subtypes().toSet();
@@ skipping 467 matching lines @@
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   bool get hasClosedWorldAssumption => !compiler.hasIncrementalSupport;
 }