Rename UniverseSelector to DynamicUse and move it to use.dart

pkg/compiler/lib/src/universe/world_impact.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.universe.world_impact;
 
 import '../dart_types.dart' show
     DartType,
     InterfaceType;
 import '../elements/elements.dart' show
     Element,
     LocalFunctionElement,
     MethodElement;
 import '../util/util.dart' show
     Setlet;
 
-import 'universe.dart' show
-    UniverseSelector;
 import 'use.dart' show
+    DynamicUse,
     StaticUse;
 
 class WorldImpact {
   const WorldImpact();
 
-  Iterable<UniverseSelector> get dynamicUses =>
-      const <UniverseSelector>[];
+  Iterable<DynamicUse> get dynamicUses =>
+      const <DynamicUse>[];
 
   Iterable<StaticUse> get staticUses => const <StaticUse>[];
 
   // TODO(johnniwinther): Replace this by called constructors with type
   // arguments.
   Iterable<InterfaceType> get instantiatedTypes => const <InterfaceType>[];
 
   // TODO(johnniwinther): Collect checked types for checked mode separately to
   // support serialization.
   Iterable<DartType> get isChecks => const <DartType>[];
@@ skipping 32 matching lines @@
     add('as-casts', worldImpact.asCasts);
     add('on-catch-types', worldImpact.onCatchTypes);
     add('closures', worldImpact.closures);
     add('type literals', worldImpact.typeLiterals);
   }
 }
 
 class WorldImpactBuilder {
   // TODO(johnniwinther): Do we benefit from lazy initialization of the
   // [Setlet]s?
-  Setlet<UniverseSelector> _dynamicUses;
+  Setlet<DynamicUse> _dynamicUses;
   Setlet<InterfaceType> _instantiatedTypes;
   Setlet<StaticUse> _staticUses;
   Setlet<DartType> _isChecks;
   Setlet<DartType> _asCasts;
   Setlet<DartType> _checkedModeChecks;
   Setlet<DartType> _onCatchTypes;
   Setlet<LocalFunctionElement> _closures;
   Setlet<DartType> _typeLiterals;
 
-  void registerDynamicUse(UniverseSelector dynamicUse) {
+  void registerDynamicUse(DynamicUse dynamicUse) {
     assert(dynamicUse != null);
     if (_dynamicUses == null) {
-      _dynamicUses = new Setlet<UniverseSelector>();
+      _dynamicUses = new Setlet<DynamicUse>();
     }
     _dynamicUses.add(dynamicUse);
   }
 
-  Iterable<UniverseSelector> get dynamicUses {
+  Iterable<DynamicUse> get dynamicUses {
     return _dynamicUses != null
-        ? _dynamicUses : const <UniverseSelector>[];
+        ? _dynamicUses : const <DynamicUse>[];
   }
 
   void registerInstantiatedType(InterfaceType type) {
     assert(type != null);
     if (_instantiatedTypes == null) {
       _instantiatedTypes = new Setlet<InterfaceType>();
     }
     _instantiatedTypes.add(type);
   }
 
@@ skipping 90 matching lines @@
   }
 }
 
 /// Mutable implementation of [WorldImpact] used to transform
 /// [ResolutionImpact] or [CodegenImpact] to [WorldImpact].
 class TransformedWorldImpact implements WorldImpact {
   final WorldImpact worldImpact;
 
   Setlet<StaticUse> _staticUses;
   Setlet<InterfaceType> _instantiatedTypes;
-  Setlet<UniverseSelector> _dynamicUses;
+  Setlet<DynamicUse> _dynamicUses;
 
   TransformedWorldImpact(this.worldImpact);
 
   @override
   Iterable<DartType> get asCasts => worldImpact.asCasts;
 
   @override
   Iterable<DartType> get checkedModeChecks => worldImpact.checkedModeChecks;
 
   @override
-  Iterable<UniverseSelector> get dynamicUses {
+  Iterable<DynamicUse> get dynamicUses {
     return _dynamicUses != null
         ? _dynamicUses : worldImpact.dynamicUses;
   }
 
   @override
   Iterable<DartType> get isChecks => worldImpact.isChecks;
 
   @override
   Iterable<DartType> get onCatchTypes => worldImpact.onCatchTypes;
 
   _unsupported(String message) => throw new UnsupportedError(message);
 
-  void registerDynamicUse(UniverseSelector selector) {
+  void registerDynamicUse(DynamicUse dynamicUse) {
     if (_dynamicUses == null) {
-      _dynamicUses = new Setlet<UniverseSelector>();
+      _dynamicUses = new Setlet<DynamicUse>();
       _dynamicUses.addAll(worldImpact.dynamicUses);
     }
-    _dynamicUses.add(selector);
+    _dynamicUses.add(dynamicUse);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     if (_instantiatedTypes == null) {
       _instantiatedTypes = new Setlet<InterfaceType>();
       _instantiatedTypes.addAll(worldImpact.instantiatedTypes);
     }
     _instantiatedTypes.add(type);
   }
 
@@ skipping 24 matching lines @@
   @override
   Iterable<LocalFunctionElement> get closures => worldImpact.closures;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('TransformedWorldImpact($worldImpact)');
     WorldImpact.printOn(sb, this);
     return sb.toString();
   }
 }