Prefix resolution_types with Resolution.

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
 import '../../constants/values.dart'
     show ConstantValue, InterceptorConstantValue;
 import '../../core_types.dart' show CommonElements;
 import '../../elements/resolution_types.dart'
-    show DartType, FunctionType, TypedefType;
+    show ResolutionDartType, ResolutionFunctionType, ResolutionTypedefType;
 import '../../deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import '../../elements/elements.dart'
     show
         ClassElement,
         Element,
         Elements,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         GetterElement,
@@ skipping 351 matching lines @@
                   interceptorClass.callStubs.add(_buildStubMethod(stubName,
                       js.js('function(obj, v) { return obj.# = v }', [jsName]),
                       element: member));
                 }
               }
             }
 
             // Generating stubs for direct calls and stubs for call-through
             // of getters that happen to be functions.
             bool isFunctionLike = false;
-            FunctionType functionType = null;
+            ResolutionFunctionType functionType = null;
 
             if (member.isFunction) {
               FunctionElement fn = member;
               functionType = fn.type;
             } else if (member.isGetter) {
               if (_compiler.options.trustTypeAnnotations) {
                 GetterElement getter = member;
-                DartType returnType = getter.type.returnType;
+                ResolutionDartType returnType = getter.type.returnType;
                 if (returnType.isFunctionType) {
                   functionType = returnType;
                 } else if (returnType.treatAsDynamic ||
                     _compiler.types.isSubtype(
                         returnType, backend.commonElements.functionType)) {
                   if (returnType.isTypedef) {
-                    TypedefType typedef = returnType;
+                    ResolutionTypedefType typedef = returnType;
                     // TODO(jacobr): can we just use typdef.unaliased instead?
                     functionType = typedef.element.functionSignature.type;
                   } else {
                     // Other misc function type such as commonElements.Function.
                     // Allow any number of arguments.
                     isFunctionLike = true;
                   }
                 }
               } else {
                 isFunctionLike = true;
@@ skipping 342 matching lines @@
       assert(invariant(element, !element.isConstructor));
     }
 
     js.Name callName = null;
     if (canTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = namer.invocationName(callSelector);
     }
 
-    DartType memberType;
+    ResolutionDartType memberType;
     if (element.isGenerativeConstructorBody) {
       // TODO(herhut): Why does this need to be normalized away? We never need
       //               this information anyway as they cannot be torn off or
       //               reflected.
       var body = element;
       memberType = body.constructor.type;
     } else {
       memberType = element.type;
     }
 
@@ skipping 19 matching lines @@
         tearOffName: tearOffName,
         isClosureCallMethod: isClosureCallMethod,
         aliasName: aliasName,
         canBeApplied: canBeApplied,
         canBeReflected: canBeReflected,
         requiredParameterCount: requiredParameterCount,
         optionalParameterDefaultValues: optionalParameterDefaultValues,
         functionType: functionType);
   }
 
-  js.Expression _generateFunctionType(DartType type, OutputUnit outputUnit) {
+  js.Expression _generateFunctionType(
+      ResolutionDartType type, OutputUnit outputUnit) {
     if (type.containsTypeVariables) {
       js.Expression thisAccess = js.js(r'this.$receiver');
       return backend.rtiEncoder.getSignatureEncoding(type, thisAccess);
     } else {
       return backend.emitter.metadataCollector
           .reifyTypeForOutputUnit(type, outputUnit);
     }
   }
 
   List<ParameterStubMethod> _generateParameterStubs(
@@ skipping 123 matching lines @@
     js.Name tearOffName =
         needsTearOff ? namer.staticClosureName(element) : null;
 
     js.Name callName = null;
     if (needsTearOff) {
       Selector callSelector =
           new Selector.fromElement(element).toCallSelector();
       callName = namer.invocationName(callSelector);
     }
     js.Expression functionType;
-    DartType type = element.type;
+    ResolutionDartType type = element.type;
     if (needsTearOff || canBeReflected) {
       OutputUnit outputUnit =
           _compiler.deferredLoadTask.outputUnitForElement(element);
       functionType = _generateFunctionType(type, outputUnit);
     }
 
     int requiredParameterCount;
     var /* List | Map */ optionalParameterDefaultValues;
     if (canBeApplied || canBeReflected) {
       FunctionSignature signature = element.functionSignature;
@@ skipping 29 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }