Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/registry.dart

 // Copyright (c) 2014, 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.resolution.registry;
 
 import '../common.dart';
 import '../common/backend_api.dart'
     show Backend, ForeignResolver, NativeRegistry;
 import '../common/resolution.dart' show ResolutionImpact, Target;
@@ skipping 212 matching lines @@
   }
 
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector) {
     mapping.setOperatorSelectorInComplexSendSet(node, selector);
   }
 
   //////////////////////////////////////////////////////////////////////////////
   //  Node-to-Type mapping functionality.
   //////////////////////////////////////////////////////////////////////////////
 
-  DartType useType(Node annotation, DartType type) {
+  ResolutionDartType useType(Node annotation, ResolutionDartType type) {
     if (type != null) {
       mapping.setType(annotation, type);
     }
     return type;
   }
 
-  void setType(Node node, DartType type) => mapping.setType(node, type);
+  void setType(Node node, ResolutionDartType type) =>
+      mapping.setType(node, type);
 
-  DartType getType(Node node) => mapping.getType(node);
+  ResolutionDartType getType(Node node) => mapping.getType(node);
 
   //////////////////////////////////////////////////////////////////////////////
   //  Node-to-Constant mapping functionality.
   //////////////////////////////////////////////////////////////////////////////
 
   ConstantExpression getConstant(Node node) => mapping.getConstant(node);
 
   void setConstant(Node node, ConstantExpression constant) {
     mapping.setConstant(node, constant);
   }
@@ skipping 74 matching lines @@
   void registerStaticUse(StaticUse staticUse) {
     impactBuilder.registerStaticUse(staticUse);
   }
 
   /// Register the use of a type.
   void registerTypeUse(TypeUse typeUse) {
     impactBuilder.registerTypeUse(typeUse);
   }
 
   /// Register checked mode check of [type] if it isn't `dynamic`.
-  void registerCheckedModeCheck(DartType type) {
+  void registerCheckedModeCheck(ResolutionDartType type) {
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
   }
 
   void registerSuperUse(SourceSpan span) {
     mapping.addSuperUse(span);
   }
 
-  void registerTypeLiteral(Send node, DartType type) {
+  void registerTypeLiteral(Send node, ResolutionDartType type) {
     mapping.setType(node, type);
     impactBuilder.registerTypeUse(new TypeUse.typeLiteral(type));
   }
 
-  void registerLiteralList(Node node, InterfaceType type,
+  void registerLiteralList(Node node, ResolutionInterfaceType type,
       {bool isConstant, bool isEmpty}) {
     setType(node, type);
     impactBuilder.registerListLiteral(
         new ListLiteralUse(type, isConstant: isConstant, isEmpty: isEmpty));
   }
 
-  void registerMapLiteral(Node node, InterfaceType type,
+  void registerMapLiteral(Node node, ResolutionInterfaceType type,
       {bool isConstant, bool isEmpty}) {
     setType(node, type);
     impactBuilder.registerMapLiteral(
         new MapLiteralUse(type, isConstant: isConstant, isEmpty: isEmpty));
   }
 
   void registerForeignCall(Node node, Element element,
       CallStructure callStructure, ResolverVisitor visitor) {
     var nativeData = target.resolveForeignCall(node, element, callStructure,
         new ForeignResolutionResolver(visitor, this));
@@ skipping 17 matching lines @@
   }
 
   void registerConstantLiteral(ConstantExpression constant) {
     impactBuilder.registerConstantLiteral(constant);
   }
 
   ClassElement defaultSuperclass(ClassElement element) {
     return target.defaultSuperclass(element);
   }
 
-  void registerInstantiation(InterfaceType type) {
+  void registerInstantiation(ResolutionInterfaceType type) {
     impactBuilder.registerTypeUse(new TypeUse.instantiation(type));
   }
 
   void registerSendStructure(Send node, SendStructure sendStructure) {
     mapping.setSendStructure(node, sendStructure);
   }
 
   void registerNewStructure(NewExpression node, NewStructure newStructure) {
     mapping.setNewStructure(node, newStructure);
   }
@@ skipping 14 matching lines @@
   final ResolutionRegistry registry;
 
   ForeignResolutionResolver(this.visitor, this.registry);
 
   @override
   ConstantExpression getConstant(Node node) {
     return registry.getConstant(node);
   }
 
   @override
-  void registerInstantiatedType(InterfaceType type) {
+  void registerInstantiatedType(ResolutionInterfaceType type) {
     registry.registerInstantiation(type);
   }
 
   @override
-  DartType resolveTypeFromString(Node node, String typeName) {
+  ResolutionDartType resolveTypeFromString(Node node, String typeName) {
     return visitor.resolveTypeFromString(node, typeName);
   }
 }