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;
         }));
   }
 }