Prefix resolution_types with Resolution.

tests/compiler/dart2js/type_test_helper.dart

Index: tests/compiler/dart2js/type_test_helper.dart
diff --git a/tests/compiler/dart2js/type_test_helper.dart b/tests/compiler/dart2js/type_test_helper.dart
index 7e112b05d8e7c2711b72e6bae862e38a8b8b4c49..c221dfe5c117e86a43aaa805bcc321b645e3024c 100644
--- a/tests/compiler/dart2js/type_test_helper.dart
+++ b/tests/compiler/dart2js/type_test_helper.dart
@@ -17,12 +17,12 @@ import 'package:compiler/src/elements/elements.dart'
 import 'package:compiler/src/world.dart' show ClosedWorld;
 
 GenericType instantiate(
-    TypeDeclarationElement element, List<DartType> arguments) {
+    TypeDeclarationElement element, List<ResolutionDartType> arguments) {
   if (element.isClass) {
-    return new InterfaceType(element, arguments);
+    return new ResolutionInterfaceType(element, arguments);
   } else {
     assert(element.isTypedef);
-    return new TypedefType(element, arguments);
+    return new ResolutionTypedefType(element, arguments);
   }
 }
 
@@ -94,50 +94,53 @@ class TypeEnvironment {
     return element;
   }
 
-  DartType getElementType(String name) {
+  ResolutionDartType getElementType(String name) {
     var element = getElement(name);
     return element.computeType(compiler.resolution);
   }
 
-  DartType operator [](String name) {
-    if (name == 'dynamic') return const DynamicType();
-    if (name == 'void') return const VoidType();
+  ResolutionDartType operator [](String name) {
+    if (name == 'dynamic') return const ResolutionDynamicType();
+    if (name == 'void') return const ResolutionVoidType();
     return getElementType(name);
   }
 
-  DartType getMemberType(ClassElement element, String name) {
+  ResolutionDartType getMemberType(ClassElement element, String name) {
     MemberElement member = element.localLookup(name);
     return member.computeType(compiler.resolution);
   }
 
-  bool isSubtype(DartType T, DartType S) {
+  bool isSubtype(ResolutionDartType T, ResolutionDartType S) {
     return compiler.types.isSubtype(T, S);
   }
 
-  bool isMoreSpecific(DartType T, DartType S) {
+  bool isMoreSpecific(ResolutionDartType T, ResolutionDartType S) {
     return compiler.types.isMoreSpecific(T, S);
   }
 
-  DartType computeLeastUpperBound(DartType T, DartType S) {
+  ResolutionDartType computeLeastUpperBound(
+      ResolutionDartType T, ResolutionDartType S) {
     return compiler.types.computeLeastUpperBound(T, S);
   }
 
-  DartType flatten(DartType T) {
+  ResolutionDartType flatten(ResolutionDartType T) {
     return compiler.types.flatten(T);
   }
 
-  FunctionType functionType(DartType returnType, List<DartType> parameters,
-      {List<DartType> optionalParameters: const <DartType>[],
-      Map<String, DartType> namedParameters}) {
+  ResolutionFunctionType functionType(
+      ResolutionDartType returnType, List<ResolutionDartType> parameters,
+      {List<ResolutionDartType> optionalParameters:
+          const <ResolutionDartType>[],
+      Map<String, ResolutionDartType> namedParameters}) {
     List<String> namedParameterNames = <String>[];
-    List<DartType> namedParameterTypes = <DartType>[];
+    List<ResolutionDartType> namedParameterTypes = <ResolutionDartType>[];
     if (namedParameters != null) {
-      namedParameters.forEach((String name, DartType type) {
+      namedParameters.forEach((String name, ResolutionDartType type) {
         namedParameterNames.add(name);
         namedParameterTypes.add(type);
       });
     }
-    return new FunctionType.synthesized(returnType, parameters,
+    return new ResolutionFunctionType.synthesized(returnType, parameters,
         optionalParameters, namedParameterNames, namedParameterTypes);
   }