Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/graph_builder.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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../compiler.dart';
 import '../constants/constant_system.dart';
 import '../elements/resolution_types.dart';
@@ skipping 183 matching lines @@
   HSubGraphBlockInformation wrapStatementGraph(SubGraph statements) {
     if (statements == null) return null;
     return new HSubGraphBlockInformation(statements);
   }
 
   HSubExpressionBlockInformation wrapExpressionGraph(SubExpression expression) {
     if (expression == null) return null;
     return new HSubExpressionBlockInformation(expression);
   }
 
-  HInstruction buildFunctionType(FunctionType type) {
+  HInstruction buildFunctionType(ResolutionFunctionType type) {
     type.accept(new ReifiedTypeRepresentationBuilder(closedWorld), this);
     return pop();
   }
 
   HInstruction buildFunctionTypeConversion(
-      HInstruction original, DartType type, int kind);
+      HInstruction original, ResolutionDartType type, int kind);
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   Element get sourceElement;
 
   // TODO(karlklose): this is needed to avoid a bug where the resolved type is
   // not stored on a type annotation in the closure translator. Remove when
   // fixed.
   bool hasDirectLocal(Local local) {
     return !localsHandler.isAccessedDirectly(local) ||
         localsHandler.directLocals[local] != null;
   }
 
-  HInstruction callSetRuntimeTypeInfoWithTypeArguments(
-      DartType type, List<HInstruction> rtiInputs, HInstruction newObject) {
+  HInstruction callSetRuntimeTypeInfoWithTypeArguments(ResolutionDartType type,
+      List<HInstruction> rtiInputs, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element)) {
       return newObject;
     }
 
     HInstruction typeInfo = new HTypeInfoExpression(
         TypeInfoExpressionKind.INSTANCE,
         (type.element as ClassElement).thisType,
         rtiInputs,
         closedWorld.commonMasks.dynamicType);
     add(typeInfo);
     return callSetRuntimeTypeInfo(typeInfo, newObject);
   }
 
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject);
 
   /// The element for which this SSA builder is being used.
   Element get targetElement;
   TypeBuilder get typeBuilder;
 }
 
 class ReifiedTypeRepresentationBuilder
     implements DartTypeVisitor<dynamic, GraphBuilder> {
   final ClosedWorld closedWorld;
 
   ReifiedTypeRepresentationBuilder(this.closedWorld);
 
-  void visit(DartType type, GraphBuilder builder) => type.accept(this, builder);
+  void visit(ResolutionDartType type, GraphBuilder builder) =>
+      type.accept(this, builder);
 
-  void visitVoidType(VoidType type, GraphBuilder builder) {
+  void visitVoidType(ResolutionVoidType type, GraphBuilder builder) {
     ClassElement cls = builder.backend.helpers.VoidRuntimeType;
     builder.push(new HVoidType(type, new TypeMask.exact(cls, closedWorld)));
   }
 
-  void visitTypeVariableType(TypeVariableType type, GraphBuilder builder) {
+  void visitTypeVariableType(
+      ResolutionTypeVariableType type, GraphBuilder builder) {
     ClassElement cls = builder.backend.helpers.RuntimeType;
     TypeMask instructionType = new TypeMask.subclass(cls, closedWorld);
     if (!builder.sourceElement.enclosingElement.isClosure &&
         builder.sourceElement.isInstanceMember) {
       HInstruction receiver = builder.localsHandler.readThis();
       builder.push(new HReadTypeVariable(type, receiver, instructionType));
     } else {
       builder.push(new HReadTypeVariable.noReceiver(
           type,
           builder.typeBuilder
               .addTypeVariableReference(type, builder.sourceElement),
           instructionType));
     }
   }
 
-  void visitFunctionType(FunctionType type, GraphBuilder builder) {
+  void visitFunctionType(ResolutionFunctionType type, GraphBuilder builder) {
     type.returnType.accept(this, builder);
     HInstruction returnType = builder.pop();
     List<HInstruction> inputs = <HInstruction>[returnType];
 
-    for (DartType parameter in type.parameterTypes) {
+    for (ResolutionDartType parameter in type.parameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
-    for (DartType parameter in type.optionalParameterTypes) {
+    for (ResolutionDartType parameter in type.optionalParameterTypes) {
       parameter.accept(this, builder);
       inputs.add(builder.pop());
     }
 
-    List<DartType> namedParameterTypes = type.namedParameterTypes;
+    List<ResolutionDartType> namedParameterTypes = type.namedParameterTypes;
     List<String> names = type.namedParameters;
     for (int index = 0; index < names.length; index++) {
       ast.DartString dartString = new ast.DartString.literal(names[index]);
       inputs.add(
           builder.graph.addConstantString(dartString, builder.closedWorld));
       namedParameterTypes[index].accept(this, builder);
       inputs.add(builder.pop());
     }
 
     ClassElement cls = builder.backend.helpers.RuntimeFunctionType;
     builder.push(
         new HFunctionType(inputs, type, new TypeMask.exact(cls, closedWorld)));
   }
 
   void visitMalformedType(MalformedType type, GraphBuilder builder) {
-    visitDynamicType(const DynamicType(), builder);
+    visitDynamicType(const ResolutionDynamicType(), builder);
   }
 
-  void visitInterfaceType(InterfaceType type, GraphBuilder builder) {
+  void visitInterfaceType(ResolutionInterfaceType type, GraphBuilder builder) {
     List<HInstruction> inputs = <HInstruction>[];
-    for (DartType typeArgument in type.typeArguments) {
+    for (ResolutionDartType typeArgument in type.typeArguments) {
       typeArgument.accept(this, builder);
       inputs.add(builder.pop());
     }
     ClassElement cls;
     if (type.typeArguments.isEmpty) {
       cls = builder.backend.helpers.RuntimeTypePlain;
     } else {
       cls = builder.backend.helpers.RuntimeTypeGeneric;
     }
     builder.push(
         new HInterfaceType(inputs, type, new TypeMask.exact(cls, closedWorld)));
   }
 
-  void visitTypedefType(TypedefType type, GraphBuilder builder) {
-    DartType unaliased = type.unaliased;
-    if (unaliased is TypedefType) throw 'unable to unalias $type';
+  void visitTypedefType(ResolutionTypedefType type, GraphBuilder builder) {
+    ResolutionDartType unaliased = type.unaliased;
+    if (unaliased is ResolutionTypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
-  void visitDynamicType(DynamicType type, GraphBuilder builder) {
+  void visitDynamicType(ResolutionDynamicType type, GraphBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.helpers.DynamicRuntimeType;
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, closedWorld)));
   }
 }