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

pkg/compiler/lib/src/universe/universe.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
@@ skipping 106 matching lines @@
   // [_instantiatedTypes] sets should be merged.
   final Set<ClassElement> _directlyInstantiatedClasses =
       new Set<ClassElement>();
 
   /// 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>();
 
+  /// The set of all instantiated classes, either directly, as superclasses or
+  /// as supertypes.
+  ///
+  /// Invariant: Elements are declaration elements.
+  final Set<ClassElement> _allInstantiatedClasses = new Set<ClassElement>();
+
   /// Classes implemented by directly instantiated classes.
   final Set<ClassElement> _implementedClasses = new Set<ClassElement>();
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   final Set<FieldElement> allReferencedStaticFields = new Set<FieldElement>();
 
   /**
    * Documentation wanted -- johnniwinther
@@ skipping 56 matching lines @@
   Universe(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;
   }
 
+  /// All instantiated classes, either directly, as superclasses or as
+  /// supertypes.
+  // TODO(johnniwinther): Improve semantic precision.
+  Iterable<ClassElement> get allInstantiatedClasses {
+    return _allInstantiatedClasses;
+  }
+
   /// 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 instantiated, either directly,
+  /// through subclasses.
+  // TODO(johnniwinther): Improve semantic precision.
+  bool isInstantiated(ClassElement cls) {
+    return _allInstantiatedClasses.contains(cls.declaration);
+  }
+
   /// 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.
   // TODO(johnniwinther): Improve semantic precision.
   bool isImplemented(ClassElement cls) {
     return _implementedClasses.contains(cls.declaration);
   }
 
   /// Register [type] as (directly) instantiated.
@@ skipping 24 matching lines @@
     // 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);
         }
       });
     }
+    while (cls != null) {
+      if (!_allInstantiatedClasses.add(cls)) {
+        return;
+      }
+      cls = cls.superclass;
+    }
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
                             Element member,
                             World world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member, world)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
@@ skipping 106 matching lines @@
     }
   }
 
   void forgetElement(Element element, Compiler compiler) {
     allClosures.remove(element);
     slowDirectlyNestedClosures(element).forEach(compiler.forgetElement);
     closurizedMembers.remove(element);
     fieldSetters.remove(element);
     fieldGetters.remove(element);
     _directlyInstantiatedClasses.remove(element);
+    _allInstantiatedClasses.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);
     }
   }
 
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
           return closure.executableContext == element;
         }));
   }
 }