Introduce isAbstractlyInstantiated to avoid exact masks of abstract classes.

pkg/compiler/lib/src/universe/world_builder.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 universe;
 
 import 'dart:collection';
 
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart';
+import '../universe/class_set.dart' show Instantiation;
+import '../util/enumset.dart';
 import '../util/util.dart';
 import '../world.dart' show World, ClosedWorld, OpenWorld;
 import 'selector.dart' show Selector;
 import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
 /// The known constraint on receiver for a dynamic call site.
 ///
 /// This can for instance be used to constrain this dynamic call to `foo` to
 /// 'receivers of the exact instance `Bar`':
 ///
@@ skipping 126 matching lines @@
   Iterable<Element> get closurizedMembers;
 
   /// Returns `true` if [cls] is considered to be implemented by an
   /// instantiated class, either directly, through subclasses or through
   /// subtypes. The latter case only contains spurious information from
   /// instantiations through factory constructors and mixins.
   bool isImplemented(ClassElement cls);
 
   /// Set of all fields that are statically known to be written to.
   Iterable<Element> get fieldSetters;
+
+  /// Call [f] for all directly or abstractly instantiated classes.
+  void forEachInstantiatedClass(
+      f(ClassElement cls, EnumSet<Instantiation> instantiations));
 }
 
 class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
-  final Set<ClassElement> _directlyInstantiatedClasses =
-      new Set<ClassElement>();
+  final Map<ClassElement, EnumSet<Instantiation>> _directlyInstantiatedClasses =
+      <ClassElement, EnumSet<Instantiation>>{};
 
   /// The set of all directly instantiated types, that is, the types of the
   /// directly instantiated classes.
   ///
   /// See [_directlyInstantiatedClasses].
   final Set<DartType> _instantiatedTypes = new Set<DartType>();
 
   /// Classes implemented by directly instantiated classes.
   final Set<ClassElement> _implementedClasses = new Set<ClassElement>();
 
@@ skipping 49 matching lines @@
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   ResolutionWorldBuilderImpl(this.selectorConstraintsStrategy);
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
-    return _directlyInstantiatedClasses;
+    return _directlyInstantiatedClasses.keys;
   }
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   ///
   /// See [directlyInstantiatedClasses].
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<DartType> get instantiatedTypes => _instantiatedTypes;
 
   /// Returns `true` if [cls] is considered to be implemented by an
@@ skipping 22 matching lines @@
         // classes; a native abstract class may have non-abstract subclasses
         // not declared to the program.  Instances of these classes are
         // indistinguishable from the abstract class.
         ||
         isNative
         // Likewise, if this registration comes from the mirror system,
         // all bets are off.
         // TODO(herhut): Track classes required by mirrors seperately.
         ||
         byMirrors) {
-      _directlyInstantiatedClasses.add(cls);
+      EnumSet<Instantiation> instantiations = _directlyInstantiatedClasses
+          .putIfAbsent(cls, () => new EnumSet<Instantiation>());
+      if (isNative || byMirrors) {
+        instantiations.add(Instantiation.ABSTRACTLY_INSTANTIATED);
+      } else {
+        instantiations.add(Instantiation.DIRECTLY_INSTANTIATED);
+      }
     }
 
     // TODO(johnniwinther): Replace this by separate more specific mappings that
     // include the type arguments.
     if (_implementedClasses.add(cls)) {
       onImplemented(cls);
       cls.allSupertypes.forEach((InterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           onImplemented(supertype.element);
         }
       });
     }
   }
 
+  @override
+  void forEachInstantiatedClass(
+      f(ClassElement cls, EnumSet<Instantiation> instantiations)) {
+    _directlyInstantiatedClasses.forEach(f);
+  }
+
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
       Element member, OpenWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
@@ skipping 354 matching lines @@
 
   void forgetElement(Element element, Compiler compiler) {
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
       assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
       _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 }