Prefix resolution_types with Resolution.

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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 js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
@@ skipping 1457 matching lines @@
   String get functionTypeVoidReturnTag => r'v';
 
   String get functionTypeReturnTypeTag => r'ret';
 
   String get functionTypeRequiredParametersTag => r'args';
 
   String get functionTypeOptionalParametersTag => r'opt';
 
   String get functionTypeNamedParametersTag => r'named';
 
-  Map<FunctionType, jsAst.Name> functionTypeNameMap =
-      new HashMap<FunctionType, jsAst.Name>();
+  Map<ResolutionFunctionType, jsAst.Name> functionTypeNameMap =
+      new HashMap<ResolutionFunctionType, jsAst.Name>();
   final FunctionTypeNamer functionTypeNamer;
 
-  jsAst.Name getFunctionTypeName(FunctionType functionType) {
+  jsAst.Name getFunctionTypeName(ResolutionFunctionType functionType) {
     return functionTypeNameMap.putIfAbsent(functionType, () {
       String proposedName = functionTypeNamer.computeName(functionType);
       return getFreshName(instanceScope, proposedName);
     });
   }
 
-  jsAst.Name operatorIsType(DartType type) {
+  jsAst.Name operatorIsType(ResolutionDartType type) {
     if (type.isFunctionType) {
       // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
       return new CompoundName([
         new StringBackedName(operatorIsPrefix),
         _literalUnderscore,
         getFunctionTypeName(type)
       ]);
     }
     return operatorIs(type.element);
   }
@@ skipping 285 matching lines @@
       if (failed) return;
       _visit(constant.fields[field]);
     }, includeSuperAndInjectedMembers: true);
   }
 
   @override
   void visitType(TypeConstantValue constant, [_]) {
     // Generates something like 'Type_String_k8F', using the simple name of the
     // type and a hash to disambiguate the same name in different libraries.
     addRoot('Type');
-    DartType type = constant.representedType;
+    ResolutionDartType type = constant.representedType;
     String name = type.element?.name;
     if (name == null) {
       // e.g. DartType 'dynamic' has no element.
       name = rtiEncoder.getTypeRepresentationForTypeConstant(type);
     }
     addIdentifier(name);
     add(getHashTag(constant, 3));
   }
 
   @override
@@ skipping 101 matching lines @@
   int visitConstructed(ConstructedConstantValue constant, [_]) {
     int hash = _hashString(3, constant.type.element.name);
     constant.type.element.forEachInstanceField((_, FieldElement field) {
       hash = _combine(hash, _visit(constant.fields[field]));
     }, includeSuperAndInjectedMembers: true);
     return hash;
   }
 
   @override
   int visitType(TypeConstantValue constant, [_]) {
-    DartType type = constant.representedType;
+    ResolutionDartType type = constant.representedType;
     // This name includes the library name and type parameters.
     String name = rtiEncoder.getTypeRepresentationForTypeConstant(type);
     return _hashString(4, name);
   }
 
   @override
   int visitInterceptor(InterceptorConstantValue constant, [_]) {
     String typeName = constant.dispatchedType.element.name;
     return _hashString(5, typeName);
   }
@@ skipping 93 matching lines @@
     return _MASK & (hash + (((_MASK >> 15) & hash) << 15));
   }
 }
 
 class FunctionTypeNamer extends BaseDartTypeVisitor {
   final RuntimeTypesEncoder rtiEncoder;
   StringBuffer sb;
 
   FunctionTypeNamer(this.rtiEncoder);
 
-  String computeName(DartType type) {
+  String computeName(ResolutionDartType type) {
     sb = new StringBuffer();
     visit(type);
     return sb.toString();
   }
 
-  visit(DartType type, [_]) {
+  visit(ResolutionDartType type, [_]) {
     type.accept(this, null);
   }
 
-  visitType(DartType type, _) {
+  visitType(ResolutionDartType type, _) {
     sb.write(type.name);
   }
 
-  visitFunctionType(FunctionType type, _) {
+  visitFunctionType(ResolutionFunctionType type, _) {
     if (rtiEncoder.isSimpleFunctionType(type)) {
       sb.write('args${type.parameterTypes.length}');
       return;
     }
     visit(type.returnType);
     sb.write('_');
-    for (DartType parameter in type.parameterTypes) {
+    for (ResolutionDartType parameter in type.parameterTypes) {
       sb.write('_');
       visit(parameter);
     }
     bool first = false;
-    for (DartType parameter in type.optionalParameterTypes) {
+    for (ResolutionDartType parameter in type.optionalParameterTypes) {
       if (!first) {
         sb.write('_');
       }
       sb.write('_');
       visit(parameter);
       first = true;
     }
     if (!type.namedParameterTypes.isEmpty) {
       first = false;
-      for (DartType parameter in type.namedParameterTypes) {
+      for (ResolutionDartType parameter in type.namedParameterTypes) {
         if (!first) {
           sb.write('_');
         }
         sb.write('_');
         visit(parameter);
         first = true;
       }
     }
   }
 }
@@ skipping 17 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }