Introduce isAbstractlyInstantiated to avoid exact masks of abstract classes.

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 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,
+  ABSTRACTLY_INSTANTIATED,
 }
 
 /// Node for [cls] in a tree forming the subclass relation of [ClassElement]s.
 ///
 /// This is used by the [ClosedWorld] to perform queries on subclass and subtype
 /// relations.
 ///
 /// For this class hierarchy:
 ///
 ///     class A {}
@@ skipping 14 matching lines @@
 ///       |
 ///       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
+    Instantiation.INDIRECTLY_INSTANTIATED,
+    Instantiation.ABSTRACTLY_INSTANTIATED,
   ], fixed: true);
 
-  /// Enum set for selecting directly instantiated classes in
+  /// Enum set for selecting directly and abstractly 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);
+  static final EnumSet<Instantiation> EXPLICITLY_INSTANTIATED =
+      new EnumSet<Instantiation>.fromValues(const <Instantiation>[
+    Instantiation.DIRECTLY_INSTANTIATED,
+    Instantiation.ABSTRACTLY_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}) {
+      bool includeUninstantiated: true,
+      bool includeAbstractlyInstantiated: 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);
     }
+    if (includeAbstractlyInstantiated) {
+      mask.add(Instantiation.ABSTRACTLY_INSTANTIATED);
+    }
     return mask;
   }
 
   final ClassHierarchyNode parentNode;
   final ClassElement cls;
   final EnumSet<Instantiation> _mask = new EnumSet<Instantiation>.fromValues(
       const <Instantiation>[Instantiation.UNINSTANTIATED]);
 
   ClassElement _leastUpperInstantiatedSubclass;
   int _instantiatedSubclassCount = 0;
 
   /// `true` if [cls] has been directly instantiated.
   ///
   /// For instance `C` but _not_ `B` in:
   ///   class B {}
   ///   class C extends B {}
   ///   main() => new C();
   ///
   bool get isDirectlyInstantiated =>
       _mask.contains(Instantiation.DIRECTLY_INSTANTIATED);
 
   void set isDirectlyInstantiated(bool value) {
     if (value != isDirectlyInstantiated) {
-      ClassHierarchyNode parent = parentNode;
-      if (value) {
-        _mask.remove(Instantiation.UNINSTANTIATED);
-        _mask.add(Instantiation.DIRECTLY_INSTANTIATED);
-        while (parent != null) {
-          parent._updateInstantiatedSubclassCount(1);
-          parent = parent.parentNode;
-        }
-      } else {
-        _mask.remove(Instantiation.DIRECTLY_INSTANTIATED);
-        if (_mask.isEmpty) {
-          _mask.add(Instantiation.UNINSTANTIATED);
-        }
-        while (parent != null) {
-          parent._updateInstantiatedSubclassCount(-1);
-          parent = parent.parentNode;
-        }
+      _updateParentInstantiatedSubclassCount(
+          Instantiation.DIRECTLY_INSTANTIATED,
+          add: value);
+    }
+  }
+
+  /// `true` if [cls] has been abstractly instantiated. This means that at
+  /// runtime instances of [cls] or unknown subclasses of [cls] are assumed to
+  /// exist.
+  ///
+  /// This is used to mark native and/or reflectable classes as instantiated.
+  /// For native classes we do not know the exact class that instantiates [cls]
+  /// so [cls] here represents the root of the subclasses. For reflectable
+  /// classes we need event abstract classes to be 'live' even though they
+  /// cannot themselves be instantiated.
+  bool get isAbstractlyInstantiated =>
+      _mask.contains(Instantiation.ABSTRACTLY_INSTANTIATED);
+
+  void set isAbstractlyInstantiated(bool value) {
+    if (value != isAbstractlyInstantiated) {
+      _updateParentInstantiatedSubclassCount(
+          Instantiation.ABSTRACTLY_INSTANTIATED,
+          add: value);
+    }
+  }
+
+  /// `true` if [cls] is either directly or abstractly instantiated.
+  bool get isExplicitlyInstantiated =>
+      isDirectlyInstantiated || isAbstractlyInstantiated;
+
+  void _updateParentInstantiatedSubclassCount(Instantiation instantiation,
+      {bool add}) {
+    ClassHierarchyNode parent = parentNode;
+    if (add) {
+      _mask.remove(Instantiation.UNINSTANTIATED);
+      _mask.add(instantiation);
+      while (parent != null) {
+        parent._updateInstantiatedSubclassCount(1);
+        parent = parent.parentNode;
+      }
+    } else {
+      _mask.remove(instantiation);
+      if (_mask.isEmpty) {
+        _mask.add(Instantiation.UNINSTANTIATED);
+      }
+      while (parent != null) {
+        parent._updateInstantiatedSubclassCount(-1);
+        parent = parent.parentNode;
       }
     }
   }
 
   /// `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 {}
@@ skipping 45 matching lines @@
   /// This means that [other] is a subclass of [cls].
   bool contains(ClassElement other) {
     while (other != null) {
       if (cls == other) return true;
       if (cls.hierarchyDepth >= other.hierarchyDepth) return false;
       other = other.superclass;
     }
     return false;
   }
 
-  /// `true` if [cls] has been directly or indirectly instantiated.
-  bool get isInstantiated => isDirectlyInstantiated || isIndirectlyInstantiated;
+  /// `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<ClassElement> subclassesByMask(EnumSet<Instantiation> mask,
       {bool strict: false}) {
     return new ClassHierarchyNodeIterable(this, mask, includeRoot: !strict);
   }
@@ skipping 60 matching lines @@
   ClassElement getLubOfInstantiatedSubclasses() {
     if (!isInstantiated) return null;
     if (_leastUpperInstantiatedSubclass == null) {
       _leastUpperInstantiatedSubclass =
           _computeLeastUpperInstantiatedSubclass();
     }
     return _leastUpperInstantiatedSubclass;
   }
 
   ClassElement _computeLeastUpperInstantiatedSubclass() {
-    if (isDirectlyInstantiated) {
+    if (isExplicitlyInstantiated) {
       return cls;
     }
+    if (!isInstantiated) {
+      return null;
+    }
     ClassHierarchyNode subclass;
     for (Link<ClassHierarchyNode> link = _directSubclasses;
         !link.isEmpty;
         link = link.tail) {
       if (link.head.isInstantiated) {
         if (subclass == null) {
           subclass = link.head;
         } else {
           return cls;
         }
@@ skipping 18 matching lines @@
     if (cls.isAbstract) {
       sb.write('abstract ');
     }
     sb.write('class ${cls.name}:');
     if (isDirectlyInstantiated) {
       sb.write(' directly');
     }
     if (isIndirectlyInstantiated) {
       sb.write(' indirectly');
     }
+    if (isAbstractlyInstantiated) {
+      sb.write(' abstractly');
+    }
     sb.write(' [');
     if (_directSubclasses.isEmpty) {
       sb.write(']');
     } else {
       var subclasses = _directSubclasses;
       if (sorted) {
         subclasses = _directSubclasses.toList()
           ..sort((a, b) {
             return a.cls.name.compareTo(b.cls.name);
           });
@@ skipping 108 matching lines @@
 
   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 (_subtypes != null) {
       for (ClassHierarchyNode subtypeNode in _subtypes) {
-        if (subtypeNode.isDirectlyInstantiated) {
+        if (subtypeNode.isExplicitlyInstantiated) {
           count++;
         }
         count += subtypeNode.instantiatedSubclassCount;
       }
     }
     return count;
   }
 
   /// Returns `true` if all instantiated subtypes of [cls] are subclasses of
   /// [cls].
@@ skipping 187 matching lines @@
   /// 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) {
+    if (node.isExplicitlyInstantiated) {
       return cls;
     }
     if (_subtypes == null) {
       return node.getLubOfInstantiatedSubclasses();
     }
     ClassHierarchyNode subtype;
     if (node.isInstantiated) {
       subtype = node;
     }
     for (ClassHierarchyNode subnode in _subtypes) {
@@ skipping 193 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(ClassElement cls);