Normalize type masks to use the least upper instantiated subclass/type.

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 44 matching lines @@
 
   /// The [ClassElement] for the [int] class defined in 'dart:core'.
   ClassElement get intClass;
 
   /// The [ClassElement] for the [double] class defined in 'dart:core'.
   ClassElement get doubleClass;
 
   /// The [ClassElement] for the [String] class defined in 'dart:core'.
   ClassElement get stringClass;
 
-  /// Returns `true` if [cls] is instantiated.
+  /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassElement cls);
 
+  /// Returns `true` if [cls] is directly instantiated.
+  bool isDirectlyInstantiated(ClassElement cls);
+
+  /// Returns `true` if [cls] is indirectly instantiated, that is through a
+  /// subclass.
+  bool isIndirectlyInstantiated(ClassElement cls);
+
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassElement cls);
 
   /// Returns `true` if the class world is closed.
   bool get isClosed;
 
   /// Return `true` if [x] is a subclass of [y].
   bool isSubclassOf(ClassElement x, ClassElement y);
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
@@ skipping 21 matching lines @@
 
   /// Returns `true` if any live class other than [cls] extends [cls].
   bool hasAnyStrictSubclass(ClassElement cls);
 
   /// Returns `true` if any live class other than [cls] implements [cls].
   bool hasAnyStrictSubtype(ClassElement cls);
 
   /// Returns `true` if all live classes that implement [cls] extend it.
   bool hasOnlySubclasses(ClassElement cls);
 
+  /// 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 getLeastUpperInstantiatedSubclass(ClassElement cls);
+
+  /// 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 getLeastUpperInstantiatedSubtype(ClassElement cls);
+
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes);
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> mixinUsesOf(ClassElement cls);
 
   /// Returns `true` if [cls] is mixed into a live class.
   bool isUsedAsMixin(ClassElement cls);
 
   /// Returns `true` if any live class that mixes in [cls] implements [type].
@@ skipping 64 matching lines @@
 
     if (y == objectClass) return true;
     if (x == objectClass) return false;
     while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
       if (x == y) return true;
       x = x.superclass;
     }
     return false;
   }
 
-  /// Returns `true` if [cls] is instantiated either directly or through a
-  /// subclass.
+  @override
   bool isInstantiated(ClassElement cls) {
-    return compiler.resolverWorld.isInstantiated(cls);
+    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+    return node != null && node.isInstantiated;
+  }
+
+  @override
+  bool isDirectlyInstantiated(ClassElement cls) {
+    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+    return node != null && node.isDirectlyInstantiated;
+  }
+
+  @override
+  bool isIndirectlyInstantiated(ClassElement cls) {
+    ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
+    return node != null && node.isIndirectlyInstantiated;
   }
 
   /// 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) {
@@ skipping 73 matching lines @@
 
   /// Returns `true` if all directly instantiated classes that implement [cls]
   /// extend it.
   bool hasOnlySubclasses(ClassElement cls) {
     Iterable<ClassElement> subtypes = strictSubtypesOf(cls);
     if (subtypes == null) return true;
     Iterable<ClassElement> subclasses = strictSubclassesOf(cls);
     return subclasses != null && (subclasses.length == subtypes.length);
   }
 
+  @override
+  ClassElement getLeastUpperInstantiatedSubclass(ClassElement cls) {
+    ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
+    return hierarchy != null
+        ? hierarchy.getLeastUpperInstantiatedSubclass() : null;
+  }
+
+  @override
+  ClassElement getLeastUpperInstantiatedSubtype(ClassElement cls) {
+    ClassSet classSet = _classSets[cls.declaration];
+    return classSet != null
+        ? classSet.getLeastUpperInstantiatedSubtype() : null;
+  }
+
   /// Returns an iterable over the common supertypes of the [classes].
   Iterable<ClassElement> commonSupertypesOf(Iterable<ClassElement> classes) {
     Iterator<ClassElement> iterator = classes.iterator;
     if (!iterator.moveNext()) return const <ClassElement>[];
 
     ClassElement cls = iterator.current;
     assert(checkInvariants(cls));
     OrderedTypeSet typeSet = cls.allSupertypesAndSelf;
     if (!iterator.moveNext()) return typeSet.types.map((type) => type.element);
 
@@ skipping 192 matching lines @@
     });
   }
 
   void populate() {
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
     void updateClassHierarchyNodeForClass(
         ClassElement cls,
         {bool directlyInstantiated: false,
          bool indirectlyInstantiated: false}) {
-      assert(!directlyInstantiated || isInstantiated(cls));
       ClassHierarchyNode node = getClassHierarchyNode(cls);
       bool changed = false;
       if (directlyInstantiated && !node.isDirectlyInstantiated) {
         node.isDirectlyInstantiated = true;
         changed = true;
       }
       if (indirectlyInstantiated && !node.isIndirectlyInstantiated) {
         node.isIndirectlyInstantiated = true;
         changed = true;
       }
       if (changed && cls.superclass != null) {
         updateClassHierarchyNodeForClass(
             cls.superclass, indirectlyInstantiated: true);
       }
+      // Ensure that classes implicitly implementing `Function` are in its
+      // subtype set.
+      if (cls != coreClasses.functionClass &&
+          cls.implementsFunction(compiler)) {
+        ClassSet subtypeSet = _ensureClassSet(coreClasses.functionClass);
+        subtypeSet.addSubtype(node);
+      }
     }
 
     void addSubtypes(ClassElement cls) {
       if (compiler.hasIncrementalSupport && !alreadyPopulated.add(cls)) {
         return;
       }
       assert(cls.isDeclaration);
       if (!cls.isResolved) {
         reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');
       }
@@ skipping 169 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;
 }