Prefix resolution_types with Resolution.

pkg/compiler/lib/src/kernel/kernel_visitor.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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 13 matching lines @@
 import '../common.dart';
 import '../common/names.dart';
 import '../constants/expressions.dart'
     show
         BoolFromEnvironmentConstantExpression,
         ConstantExpression,
         ConstructedConstantExpression,
         IntFromEnvironmentConstantExpression,
         StringFromEnvironmentConstantExpression,
         TypeConstantExpression;
-import '../elements/resolution_types.dart' show DartType, InterfaceType;
+import '../elements/resolution_types.dart'
+    show ResolutionDartType, ResolutionInterfaceType;
 import '../diagnostics/spannable.dart' show Spannable;
 import '../elements/elements.dart'
     show
         AstElement,
         AsyncMarker,
         ClassElement,
         ConstructorElement,
         Element,
         FieldElement,
         FunctionElement,
@@ skipping 207 matching lines @@
     }
   }
 
   ir.DartType computeType(TypeAnnotation node) {
     if (node == null) return const ir.DynamicType();
     return kernel.typeToIr(elements.getType(node));
   }
 
   // This works around a bug in dart2js.
   // TODO(ahe): Fix the bug in dart2js and remove this function.
-  ir.DartType typeToIrHack(DartType type) {
+  ir.DartType typeToIrHack(ResolutionDartType type) {
     if (currentElement.isSynthesized &&
         currentElement.enclosingClass.isMixinApplication &&
         !kernel.hasHierarchyProblem(currentElement.enclosingClass)) {
       // Dart2js doesn't compute the correct functionSignature for synthetic
       // constructors in mixin applications. So we compute the correct type:
       // First, find the first superclass that isn't a mixin.
       ClassElement superclass = currentElement.enclosingClass.superclass;
       while (superclass.isMixinApplication) {
         superclass = superclass.superclass;
       }
       // Then translate the "this type" of the mixin application to its
       // supertype with the correct type arguments.
       //
       // Consider this example:
       //
       //     class Super<S> {}
       //     class Sub<T> extends Object with Super<T> {}
       //
       // Here the problem is that dart2js has created a constructor that refers
       // to S (not T) in Sub (for example, the return type of the constructor
       // is Super<S> and it should be Sub<T>, but we settle for Super<T> for
       // now). So we need to translate Sub<T> to an instance of Super, which is
       // Super<T> (not Super<S>).
-      InterfaceType supertype =
+      ResolutionInterfaceType supertype =
           currentElement.enclosingClass.asInstanceOf(superclass);
       // Once we have [supertype], we know how to substitute S with T: the type
       // arguments of [supertype] corresponds to T, and the type variables of
       // its element correspond to S.
       type =
           type.subst(supertype.typeArguments, supertype.element.typeVariables);
     }
     return kernel.typeToIr(type);
   }
 
@@ skipping 817 matching lines @@
   @override
   ir.YieldStatement visitYield(Yield node) {
     return new ir.YieldStatement(visitForValue(node.expression),
         isYieldStar: node.hasStar);
   }
 
   @override
   ir.InvalidExpression visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement element,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return new ir.InvalidExpression();
   }
 
   IrFunction buildIrFunction(
       ir.ProcedureKind kind, FunctionElement function, Node body) {
     return new IrFunction.procedure(kind, buildFunctionNode(function, body));
   }
 
   @override
   IrFunction visitAbstractGetterDeclaration(
       FunctionExpression node, MethodElement getter, _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, null);
   }
 
   @override
   IrFunction visitAbstractSetterDeclaration(
       FunctionExpression node, MethodElement setter, NodeList parameters, _) {
     return buildIrFunction(ir.ProcedureKind.Setter, setter, null);
   }
 
   @override
-  ir.AsExpression visitAs(Send node, Node expression, DartType type, _) {
+  ir.AsExpression visitAs(
+      Send node, Node expression, ResolutionDartType type, _) {
     return new ir.AsExpression(
         visitForValue(expression), kernel.typeToIr(type));
   }
 
   @override
   ir.MethodInvocation visitBinary(
       Send node, Node left, BinaryOperator operator, Node right, _) {
     return associateNode(
         buildBinaryOperator(left, operator.selectorName, right), node);
   }
 
   ir.Expression buildConstructorInvoke(NewExpression node, {bool isConst}) {
     ConstructorElement constructor = elements[node.send];
     ConstructorTarget target =
         kernel.computeEffectiveTarget(constructor, elements.getType(node));
     NodeList arguments = node.send.argumentsNode;
     if (kernel.isSyntheticError(target.element)) {
       return new ir.MethodInvocation(new ir.InvalidExpression(),
           kernel.irName("call", currentElement), buildArguments(arguments));
     }
     ir.InvocationExpression invoke = target.element.isGenerativeConstructor
         ? buildGenerativeConstructorInvoke(target.element, arguments,
             isConst: isConst)
         : buildStaticInvoke(target.element, arguments, isConst: isConst);
     if (target.type.isInterfaceType) {
-      InterfaceType type = target.type;
+      ResolutionInterfaceType type = target.type;
       if (type.isGeneric) {
         invoke.arguments.types.addAll(kernel.typesToIr(type.typeArguments));
       }
     }
     return invoke;
   }
 
   @override
   ir.InvocationExpression visitBoolFromEnvironmentConstructorInvoke(
       NewExpression node, BoolFromEnvironmentConstantExpression constant, _) {
@@ skipping 68 matching lines @@
   visitConstantInvoke(Send node, ConstantExpression constant,
       NodeList arguments, CallStructure callStructure, _) {
     // TODO(ahe): This method is never called. Is it a bug in semantic visitor?
     return internalError(node, "ConstantInvoke");
   }
 
   @override
   ir.InvalidExpression visitConstructorIncompatibleInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return new ir.InvalidExpression();
   }
 
   @override
   ir.PropertyGet visitDynamicPropertyGet(
       Send node, Node receiver, Name name, _) {
     return associateNode(
@@ skipping 88 matching lines @@
   @override
   IrFunction visitFactoryConstructorDeclaration(FunctionExpression node,
       ConstructorElement constructor, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Factory, constructor, body);
   }
 
   @override
   ir.InvocationExpression visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   @override
   ir.Initializer visitFieldInitializer(
       SendSet node, FieldElement field, Node expression, _) {
     if (kernel.isSyntheticError(field)) {
@@ skipping 108 matching lines @@
     ir.Arguments argumentsNode = buildArguments(arguments);
     ir.Constructor target = kernel.functionToIr(constructor);
     return new ir.ConstructorInvocation(target, argumentsNode,
         isConst: isConst);
   }
 
   @override
   ir.InvocationExpression visitGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   Accessor buildNullAwarePropertyAccessor(Node receiver, Name name) {
     return new NullAwarePropertyAccessor(
         visitForValue(receiver), nameToIrName(name), null, null, null);
   }
@@ skipping 51 matching lines @@
   ir.Expression visitIfNull(Send node, Node left, Node right, _) {
     var leftValue = new ir.VariableDeclaration.forValue(visitForValue(left));
     return new ir.Let(
         leftValue,
         new ir.ConditionalExpression(buildIsNull(new ir.VariableGet(leftValue)),
             visitForValue(right), new ir.VariableGet(leftValue), null));
   }
 
   @override
   ir.Initializer visitImplicitSuperConstructorInvoke(FunctionExpression node,
-      ConstructorElement superConstructor, InterfaceType type, _) {
+      ConstructorElement superConstructor, ResolutionInterfaceType type, _) {
     if (superConstructor == null) {
       // TODO(ahe): Semantic visitor shouldn't call this.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
         kernel.functionToIr(superConstructor), new ir.Arguments.empty());
   }
 
   Accessor buildIndexAccessor(Node receiver, Node index) {
     return IndexAccessor.make(
@@ skipping 75 matching lines @@
       MethodElement setter, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Setter, setter, body);
   }
 
   @override
   ir.InvocationExpression visitIntFromEnvironmentConstructorInvoke(
       NewExpression node, IntFromEnvironmentConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
   }
 
-  ir.IsExpression buildIs(Node expression, DartType type) {
+  ir.IsExpression buildIs(Node expression, ResolutionDartType type) {
     return new ir.IsExpression(
         visitForValue(expression), kernel.typeToIr(type));
   }
 
   @override
-  ir.IsExpression visitIs(Send node, Node expression, DartType type, _) {
+  ir.IsExpression visitIs(
+      Send node, Node expression, ResolutionDartType type, _) {
     return buildIs(expression, type);
   }
 
   @override
-  ir.Not visitIsNot(Send node, Node expression, DartType type, _) {
+  ir.Not visitIsNot(Send node, Node expression, ResolutionDartType type, _) {
     return new ir.Not(buildIs(expression, type));
   }
 
   ir.VariableDeclaration buildLocalVariableDeclaration(
       LocalVariableElement variable, Node initializer) {
     ir.Expression initializerNode = visitForValue(initializer);
     ir.VariableDeclaration local = getLocal(variable);
     if (initializer != null) {
       local.initializer = initializerNode;
       initializerNode.parent = local;
@@ skipping 200 matching lines @@
     return new VariableAccessor(getLocal(local)).buildNullAwareAssignment(
         visitForValue(rhs), null,
         voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitRedirectingFactoryConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
-      DartType redirectionType, // TODO(ahe): Should be InterfaceType.
+      ResolutionDartType redirectionType, // TODO(ahe): Should be InterfaceType.
       ConstructorElement redirectionTarget,
       _) {
     if (!constructor.isFactoryConstructor) {
       // TODO(ahe): This seems like a bug in semantic visitor and how it
       // recovers from a bad constructor.
       return new IrFunction.constructor(buildFunctionNode(constructor, null),
           <ir.Initializer>[new ir.InvalidInitializer()]);
     }
     ir.Statement body = null;
     if (kernel.isSyntheticError(redirectionTarget)) {
       body = new ir.InvalidStatement();
     } else {
       // TODO(ahe): This should be implemented, but doesn't matter much unless
       // we support reflection. At the call-site, we bypass this factory and
       // call its effective target directly. So this factory is only necessary
       // for reflection.
       body = new ir.InvalidStatement();
     }
     IrFunction function =
         buildIrFunction(ir.ProcedureKind.Factory, constructor, null);
     function.node.body = body..parent = function.node;
     return function;
   }
 
   @override
   ir.InvocationExpression visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
+      ResolutionInterfaceType effectiveTargetType,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   @override
   IrFunction visitRedirectingGenerativeConstructorDeclaration(
       FunctionExpression node,
       ConstructorElement constructor,
       NodeList parameters,
       NodeList initializers,
       _) {
     return buildGenerativeConstructor(constructor, parameters, null);
   }
 
   @override
   ir.InvocationExpression visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     return buildConstructorInvoke(node, isConst: false);
   }
 
   @override
   visitStaticConstantDeclaration(VariableDefinitions node, Node definition,
       FieldElement field, ConstantExpression constant, _) {
     // Shouldn't be called, handled by fieldToIr.
@@ skipping 88 matching lines @@
           kernel.parameterInitializerNodeToConstant[initializer] =
               parameter.constant;
         }
       });
       if (function.isGenerativeConstructor) {
         returnType = const ir.VoidType();
       } else {
         returnType = typeToIrHack(signature.type.returnType);
       }
       if (function.isFactoryConstructor) {
-        InterfaceType type = function.enclosingClass.thisType;
+        ResolutionInterfaceType type = function.enclosingClass.thisType;
         if (type.isGeneric) {
           typeParameters = new List<ir.TypeParameter>();
-          for (DartType parameter in type.typeArguments) {
+          for (ResolutionDartType parameter in type.typeArguments) {
             typeParameters.add(kernel.typeVariableToIr(parameter.element));
           }
         }
       }
     }
     ir.AsyncMarker asyncMarker = ir.AsyncMarker.Sync;
     if (!kernel.isSyntheticError(function)) {
       switch (function.asyncMarker) {
         case AsyncMarker.SYNC:
           asyncMarker = ir.AsyncMarker.Sync;
@@ skipping 213 matching lines @@
         node,
         buildSuperIndexAccessor(index, getter, setter),
         kernel.irName(operator.selectorName, currentElement),
         visitForValue(rhs));
   }
 
   @override
   ir.Initializer visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
-      InterfaceType type,
+      ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
     if (kernel.isSyntheticError(superConstructor)) {
       // TODO(ahe): Semantic visitor shouldn't call in this case.
       return new ir.InvalidInitializer();
     }
     return new ir.SuperInitializer(
         kernel.functionToIr(superConstructor), buildArguments(arguments));
   }
@@ skipping 539 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }