Prefix resolution_types with Resolution.

tests/compiler/dart2js/kernel/impact_test.dart

 // Copyright (c) 2016, 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.kernel.impact_test;
 
 import 'package:async_helper/async_helper.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/common/names.dart';
@@ skipping 689 matching lines @@
 ResolutionImpact laxImpact(
     Compiler compiler, AstElement element, ResolutionImpact impact) {
   ResolutionWorldImpactBuilder builder =
       new ResolutionWorldImpactBuilder('Lax impact of ${element}');
   for (StaticUse staticUse in impact.staticUses) {
     switch (staticUse.kind) {
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
         ConstructorElement constructor = staticUse.element;
         ConstructorElement effectiveTarget = constructor.effectiveTarget;
-        DartType effectiveTargetType =
+        ResolutionDartType effectiveTargetType =
             constructor.computeEffectiveTargetType(staticUse.type);
         builder.registerStaticUse(
             staticUse.kind == StaticUseKind.CONST_CONSTRUCTOR_INVOKE
                 ? new StaticUse.constConstructorInvoke(
                     effectiveTarget.declaration, null, effectiveTargetType)
                 : new StaticUse.typedConstructorInvoke(
                     effectiveTarget.declaration, null, effectiveTargetType));
         break;
       default:
         builder.registerStaticUse(staticUse);
@@ skipping 63 matching lines @@
       default:
         builder.registerFeature(feature);
         break;
     }
   }
   impact.nativeData.forEach(builder.registerNativeData);
   return builder;
 }
 
 /// Visitor the performers unaliasing of all typedefs nested within a
-/// [DartType].
-class Unaliaser extends BaseDartTypeVisitor<dynamic, DartType> {
+/// [ResolutionDartType].
+class Unaliaser extends BaseDartTypeVisitor<dynamic, ResolutionDartType> {
   const Unaliaser();
 
   @override
-  DartType visit(DartType type, [_]) => type.accept(this, null);
+  ResolutionDartType visit(ResolutionDartType type, [_]) =>
+      type.accept(this, null);
 
   @override
-  DartType visitType(DartType type, _) => type;
+  ResolutionDartType visitType(ResolutionDartType type, _) => type;
 
-  List<DartType> visitList(List<DartType> types) => types.map(visit).toList();
+  List<ResolutionDartType> visitList(List<ResolutionDartType> types) =>
+      types.map(visit).toList();
 
   @override
-  DartType visitInterfaceType(InterfaceType type, _) {
+  ResolutionDartType visitInterfaceType(ResolutionInterfaceType type, _) {
     return type.createInstantiation(visitList(type.typeArguments));
   }
 
   @override
-  DartType visitTypedefType(TypedefType type, _) {
+  ResolutionDartType visitTypedefType(ResolutionTypedefType type, _) {
     return visit(type.unaliased);
   }
 
   @override
-  DartType visitFunctionType(FunctionType type, _) {
-    return new FunctionType.synthesized(
+  ResolutionDartType visitFunctionType(ResolutionFunctionType type, _) {
+    return new ResolutionFunctionType.synthesized(
         visit(type.returnType),
         visitList(type.parameterTypes),
         visitList(type.optionalParameterTypes),
         type.namedParameters,
         visitList(type.namedParameterTypes));
   }
 }
 
-/// Perform unaliasing of all typedefs nested within a [DartType].
-DartType unalias(DartType type) {
+/// Perform unaliasing of all typedefs nested within a [ResolutionDartType].
+ResolutionDartType unalias(ResolutionDartType type) {
   return const Unaliaser().visit(type);
 }