Prefix resolution_types with Resolution.

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 '../cache_strategy.dart';
 import '../common.dart';
@@ skipping 139 matching lines @@
 // TODO(johnniwinther): Move common implementation to a [WorldBuilderBase] when
 // universes and worlds have been unified.
 abstract class WorldBuilder {
   /// 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;
 
   /// All types that are checked either through is, as or checked mode checks.
-  Iterable<DartType> get isChecks;
+  Iterable<ResolutionDartType> get isChecks;
 
   /// Registers that [type] is checked in this universe. The unaliased type is
   /// returned.
-  DartType registerIsCheck(DartType type);
+  ResolutionDartType registerIsCheck(ResolutionDartType type);
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   // TODO(johnniwinther): Improve semantic precision.
-  Iterable<DartType> get instantiatedTypes;
+  Iterable<ResolutionDartType> get instantiatedTypes;
 }
 
 abstract class ResolutionWorldBuilder implements WorldBuilder, OpenWorld {
   /// Set of (live) local functions (closures) whose signatures reference type
   /// variables.
   ///
   /// A live function is one whose enclosing member function has been enqueued.
   Iterable<Element> get closuresWithFreeTypeVariables;
 
   /// Set of (live) `call` methods whose signatures reference type variables.
@@ skipping 27 matching lines @@
 
   /// The closed world computed by this world builder.
   ///
   /// This is only available after the world builder has been closed.
   ClosedWorld get closedWorldForTesting;
 }
 
 /// The type and kind of an instantiation registered through
 /// `ResolutionWorldBuilder.registerTypeInstantiation`.
 class Instance {
-  final InterfaceType type;
+  final ResolutionInterfaceType type;
   final Instantiation kind;
   final bool isRedirection;
 
   Instance(this.type, this.kind, {this.isRedirection: false});
 
   int get hashCode {
     return Hashing.objectHash(
         type, Hashing.objectHash(kind, Hashing.objectHash(isRedirection)));
   }
 
@@ skipping 80 matching lines @@
   ///      DivElement: {
   ///        DivElement abstractly, // from `new DivElement()`
   ///      },
   ///    }
   ///
   /// If the constructor is unknown, for instance for native or mirror usage,
   /// `null` is used as key.
   Map<ConstructorElement, Set<Instance>> instantiationMap;
 
   /// Register [type] as the instantiation [kind] using [constructor].
-  void addInstantiation(
-      ConstructorElement constructor, InterfaceType type, Instantiation kind,
+  void addInstantiation(ConstructorElement constructor,
+      ResolutionInterfaceType type, Instantiation kind,
       {bool isRedirection: false}) {
     instantiationMap ??= <ConstructorElement, Set<Instance>>{};
     instantiationMap
         .putIfAbsent(constructor, () => new Set<Instance>())
         .add(new Instance(type, kind, isRedirection: isRedirection));
     switch (kind) {
       case Instantiation.DIRECTLY_INSTANTIATED:
         isDirectlyInstantiated = true;
         break;
       case Instantiation.ABSTRACTLY_INSTANTIATED:
@@ skipping 86 matching lines @@
   final Map<String, Set<_MemberUsage>> _instanceMembersByName =
       <String, Set<_MemberUsage>>{};
 
   /// Map containing instance methods of live classes that are not yet
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
   /// Fields set.
   final Set<Element> fieldSetters = new Set<Element>();
-  final Set<DartType> isChecks = new Set<DartType>();
+  final Set<ResolutionDartType> isChecks = new Set<ResolutionDartType>();
 
   /**
    * Set of (live) [:call:] methods whose signatures reference type variables.
    *
    * A live [:call:] method is one whose enclosing class has been instantiated.
    */
   final Set<Element> callMethodsWithFreeTypeVariables = new Set<Element>();
 
   /**
    * Set of (live) local functions (closures) whose signatures reference type
@@ skipping 82 matching lines @@
       }
     });
     return classes;
   }
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   ///
   /// See [directlyInstantiatedClasses].
   // TODO(johnniwinther): Improve semantic precision.
-  Iterable<DartType> get instantiatedTypes {
-    Set<InterfaceType> types = new Set<InterfaceType>();
+  Iterable<ResolutionDartType> get instantiatedTypes {
+    Set<ResolutionInterfaceType> types = new Set<ResolutionInterfaceType>();
     getInstantiationMap().forEach((_, InstantiationInfo info) {
       if (info.instantiationMap != null) {
         for (Set<Instance> instances in info.instantiationMap.values) {
           for (Instance instance in instances) {
             types.add(instance.type);
           }
         }
       }
     });
     return types;
   }
 
   /// 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.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(
-      InterfaceType type, ClassUsedCallback classUsed,
+      ResolutionInterfaceType type, ClassUsedCallback classUsed,
       {ConstructorElement constructor,
       bool byMirrors: false,
       bool isRedirection: false}) {
     ClassElement cls = type.element;
     cls.ensureResolved(_resolution);
     InstantiationInfo info =
         _instantiationInfo.putIfAbsent(cls, () => new InstantiationInfo());
     Instantiation kind = Instantiation.UNINSTANTIATED;
     bool isNative = _backend.isNative(cls);
     if (!cls.isAbstract ||
@@ skipping 13 matching lines @@
       }
       _processInstantiatedClass(cls, classUsed);
     }
     info.addInstantiation(constructor, type, kind,
         isRedirection: isRedirection);
 
     // TODO(johnniwinther): Use [_instantiationInfo] to compute this information
     // instead.
     if (_implementedClasses.add(cls)) {
       classUsed(cls, _getClassUsage(cls).implement());
-      cls.allSupertypes.forEach((InterfaceType supertype) {
+      cls.allSupertypes.forEach((ResolutionInterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           classUsed(
               supertype.element, _getClassUsage(supertype.element).implement());
         }
       });
     }
   }
 
   @override
   void forEachInstantiatedClass(f(ClassElement cls, InstantiationInfo info)) {
@@ skipping 34 matching lines @@
             .forEach((ConstructorElement constructor, Set<Instance> set) {
           for (Instance instance in set) {
             if (instance.isRedirection) {
               continue;
             }
             if (constructor == null || !constructor.isRedirectingFactory) {
               infoFor(cls)
                   .addInstantiation(constructor, instance.type, instance.kind);
             } else {
               ConstructorElement target = constructor.effectiveTarget;
-              InterfaceType targetType =
+              ResolutionInterfaceType targetType =
                   constructor.computeEffectiveTargetType(instance.type);
               Instantiation kind = Instantiation.DIRECTLY_INSTANTIATED;
               if (target.enclosingClass.isAbstract) {
                 // If target is a factory constructor on an abstract class.
                 kind = Instantiation.UNINSTANTIATED;
               }
               infoFor(targetType.element)
                   .addInstantiation(target, targetType, kind);
             }
           }
@@ skipping 59 matching lines @@
     ReceiverConstraint mask = dynamicUse.mask;
     Map<Selector, SelectorConstraints> selectors = selectorMap.putIfAbsent(
         name, () => new Maplet<Selector, SelectorConstraints>());
     UniverseSelectorConstraints constraints =
         selectors.putIfAbsent(selector, () {
       return selectorConstraintsStrategy.createSelectorConstraints(selector);
     });
     return constraints.addReceiverConstraint(mask);
   }
 
-  DartType registerIsCheck(DartType type) {
+  ResolutionDartType registerIsCheck(ResolutionDartType type) {
     type.computeUnaliased(_resolution);
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
   }
 
   void registerStaticUse(StaticUse staticUse, MemberUsedCallback memberUsed) {
@@ skipping 231 matching lines @@
       return new ClassHierarchyNode(parentNode, cls);
     });
   }
 
   ClassSet _ensureClassSet(ClassElement cls) {
     cls = cls.declaration;
     return _classSets.putIfAbsent(cls, () {
       ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
       ClassSet classSet = new ClassSet(node);
 
-      for (InterfaceType type in cls.allSupertypes) {
+      for (ResolutionInterfaceType type in cls.allSupertypes) {
         // TODO(johnniwinther): Optimization: Avoid adding [cls] to
         // superclasses.
         ClassSet subtypeSet = _ensureClassSet(type.element);
         subtypeSet.addSubtype(node);
       }
       if (cls.isMixinApplication) {
         // TODO(johnniwinther): Store this in the [ClassSet].
         MixinApplicationElement mixinApplication = cls;
         if (mixinApplication.mixin != null) {
           // If [mixinApplication] is malformed [mixin] is `null`.
@@ skipping 54 matching lines @@
           directlyInstantiated: info.isDirectlyInstantiated,
           abstractlyInstantiated: info.isAbstractlyInstantiated);
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       ClassElement superclass = cls.superclass;
       while (superclass != null) {
         Set<Element> typesImplementedBySubclassesOfCls =
             typesImplementedBySubclasses.putIfAbsent(
                 superclass, () => new Set<ClassElement>());
-        for (DartType current in cls.allSupertypes) {
+        for (ResolutionDartType current in cls.allSupertypes) {
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         superclass = superclass.superclass;
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
@@ skipping 87 matching lines @@
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_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>();
+  final Set<ResolutionDartType> _instantiatedTypes =
+      new Set<ResolutionDartType>();
 
   /// 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>();
 
   /**
@@ skipping 26 matching lines @@
   /// Map containing instance members of live classes that are not yet live
   /// themselves.
   final Map<String, Set<_MemberUsage>> _instanceMembersByName =
       <String, Set<_MemberUsage>>{};
 
   /// Map containing instance methods of live classes that are not yet
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
-  final Set<DartType> isChecks = new Set<DartType>();
+  final Set<ResolutionDartType> isChecks = new Set<ResolutionDartType>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   CodegenWorldBuilderImpl(this._backend, this.selectorConstraintsStrategy);
 
   void open(ClosedWorld closedWorld) {
     assert(invariant(NO_LOCATION_SPANNABLE, __world == null,
         message: "CodegenWorldBuilder has already been opened."));
     __world = closedWorld;
   }
@@ skipping 21 matching lines @@
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
   }
 
   /// 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;
+  Iterable<ResolutionDartType> get instantiatedTypes => _instantiatedTypes;
 
   /// Register [type] as (directly) instantiated.
   ///
   /// If [byMirrors] is `true`, the instantiation is through mirrors.
   // TODO(johnniwinther): Fully enforce the separation between exact, through
   // subclass and through subtype instantiated types/classes.
   // TODO(johnniwinther): Support unknown type arguments for generic types.
   void registerTypeInstantiation(
-      InterfaceType type, ClassUsedCallback classUsed,
+      ResolutionInterfaceType type, ClassUsedCallback classUsed,
       {bool byMirrors: false}) {
     ClassElement cls = type.element;
     bool isNative = _backend.isNative(cls);
     _instantiatedTypes.add(type);
     if (!cls.isAbstract
         // We can't use the closed-world assumption with native abstract
         // 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 separately.
         ||
         byMirrors) {
       _directlyInstantiatedClasses.add(cls);
       _processInstantiatedClass(cls, classUsed);
     }
 
     // TODO(johnniwinther): Replace this by separate more specific mappings that
     // include the type arguments.
     if (_implementedClasses.add(cls)) {
       classUsed(cls, _getClassUsage(cls).implement());
-      cls.allSupertypes.forEach((InterfaceType supertype) {
+      cls.allSupertypes.forEach((ResolutionInterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           classUsed(
               supertype.element, _getClassUsage(supertype.element).implement());
         }
       });
     }
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
       Element member, ClosedWorld world) {
@@ skipping 102 matching lines @@
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedGetters.forEach(f);
   }
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedSetters.forEach(f);
   }
 
-  DartType registerIsCheck(DartType type) {
+  ResolutionDartType registerIsCheck(ResolutionDartType type) {
     type = type.unaliased;
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
   }
 
   void _registerStaticUse(StaticUse staticUse) {
     Element element = staticUse.element;
@@ skipping 546 matching lines @@
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }
 
 void removeFromSet(Map<String, Set<_MemberUsage>> map, Element element) {
   Set<_MemberUsage> set = map[element.name];
   if (set == null) return;
   set.removeAll(
       set.where((_MemberUsage usage) => usage.entity == element).toList());
 }