Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 284 matching lines @@
     }
     assert(result.isValid());
     return result;
   }
 
   void addWithPosition(HInstruction instruction, ast.Node node) {
     add(attachPosition(instruction, node));
   }
 
   HTypeConversion buildFunctionTypeConversion(
-      HInstruction original, DartType type, int kind) {
+      HInstruction original, ResolutionDartType type, int kind) {
     HInstruction reifiedType = buildFunctionType(type);
     return new HTypeConversion.viaMethodOnType(
         type, kind, original.instructionType, reifiedType, original);
   }
 
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
@@ skipping 86 matching lines @@
     }
     return compiledArguments;
   }
 
   /**
    * Try to inline [element] within the correct context of the builder. The
    * insertion point is the state of the builder.
    */
   bool tryInlineMethod(Element element, Selector selector, TypeMask mask,
       List<HInstruction> providedArguments, ast.Node currentNode,
-      {InterfaceType instanceType}) {
+      {ResolutionInterfaceType instanceType}) {
     registry
         .addImpact(backend.registerUsedElement(element, forResolution: false));
 
     if (backend.isJsInterop(element) && !element.isFactoryConstructor) {
       // We only inline factory JavaScript interop constructors.
       return false;
     }
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
@@ skipping 224 matching lines @@
   ClassElement get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       var closureClass = cls;
       return closureClass.methodElement.enclosingClass;
     } else {
       return cls;
     }
   }
 
-  /// A stack of [DartType]s that have been seen during inlining of factory
-  /// constructors.  These types are preserved in [HInvokeStatic]s and
+  /// A stack of [ResolutionDartType]s that have been seen during inlining of
+  /// factory constructors.  These types are preserved in [HInvokeStatic]s and
   /// [HCreate]s inside the inline code and registered during code generation
   /// for these nodes.
   // TODO(karlklose): consider removing this and keeping the (substituted) types
   // of the type variables in an environment (like the [LocalsHandler]).
-  final List<DartType> currentInlinedInstantiations = <DartType>[];
+  final List<ResolutionDartType> currentInlinedInstantiations =
+      <ResolutionDartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
-  DartType returnType;
+  ResolutionDartType returnType;
 
   bool inTryStatement = false;
 
   ConstantValue getConstantForNode(ast.Node node) {
     ConstantValue constantValue =
         backend.constants.getConstantValueForNode(node, elements);
     assert(invariant(node, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
@@ skipping 170 matching lines @@
    * This method sets up the local state of the builder for inlining [function].
    * The arguments of the function are inserted into the [localsHandler].
    *
    * When inlining a function, [:return:] statements are not emitted as
    * [HReturn] instructions. Instead, the value of a synthetic element is
    * updated in the [localsHandler]. This function creates such an element and
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       FunctionElement function, List<HInstruction> compiledArguments,
-      {InterfaceType instanceType}) {
+      {ResolutionInterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, instanceType, compiler);
     localsHandler.closureData =
         compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
     returnLocal = new SyntheticLocal("result", function);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
     }
 
     FunctionSignature signature = function.functionSignature;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = compiledArguments[argumentIndex++];
       localsHandler.updateLocal(parameter, argument);
     });
 
     ClassElement enclosing = function.enclosingClass;
     if ((function.isConstructor || function.isGenerativeConstructorBody) &&
         backend.classNeedsRti(enclosing)) {
-      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
+      enclosing.typeVariables
+          .forEach((ResolutionTypeVariableType typeVariable) {
         HInstruction argument = compiledArguments[argumentIndex++];
         localsHandler.updateLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable), argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
     returnType = signature.type.returnType;
     stack = <HInstruction>[];
 
@@ skipping 20 matching lines @@
         resolvedAst.element.implementation);
 
     if (resolvedAst.element.isGenerativeConstructor) {
       buildFactory(resolvedAst);
     } else {
       ast.FunctionExpression functionNode = resolvedAst.node;
       functionNode.body.accept(this);
     }
   }
 
-  addInlinedInstantiation(DartType type) {
+  addInlinedInstantiation(ResolutionDartType type) {
     if (type != null) {
       currentInlinedInstantiations.add(type);
     }
   }
 
-  removeInlinedInstantiation(DartType type) {
+  removeInlinedInstantiation(ResolutionDartType type) {
     if (type != null) {
       currentInlinedInstantiations.removeLast();
     }
   }
 
   bool providedArgumentsKnownToBeComplete(ast.Node currentNode) {
     /* When inlining the iterator methods generated for a [:for-in:] loop, the
      * [currentNode] is the [ForIn] tree. The compiler-generated iterator
      * invocations are known to have fully specified argument lists, no default
      * arguments are used. See invocations of [pushInvokeDynamic] in
@@ skipping 18 matching lines @@
       constructorResolvedAsts.add(constructorResolvedAst);
       ClassElement enclosingClass = callee.enclosingClass;
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
-        InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
+        ResolutionInterfaceType type =
+            currentClass.thisType.asInstanceOf(enclosingClass);
         type = localsHandler.substInContext(type);
-        List<DartType> arguments = type.typeArguments;
-        List<DartType> typeVariables = enclosingClass.typeVariables;
+        List<ResolutionDartType> arguments = type.typeArguments;
+        List<ResolutionDartType> typeVariables = enclosingClass.typeVariables;
         if (!type.isRaw) {
           assert(arguments.length == typeVariables.length);
-          Iterator<DartType> variables = typeVariables.iterator;
-          type.typeArguments.forEach((DartType argument) {
+          Iterator<ResolutionDartType> variables = typeVariables.iterator;
+          type.typeArguments.forEach((ResolutionDartType argument) {
             variables.moveNext();
-            TypeVariableType typeVariable = variables.current;
+            ResolutionTypeVariableType typeVariable = variables.current;
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(typeVariable),
                 typeBuilder.analyzeTypeArgument(argument, sourceElement));
           });
         } else {
           // If the supertype is a raw type, we need to set to null the
           // type variables.
-          for (TypeVariableType variable in typeVariables) {
+          for (ResolutionTypeVariableType variable in typeVariables) {
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(variable),
                 graph.addConstantNull(closedWorld));
           }
         }
       }
 
       // For redirecting constructors, the fields will be initialized later
       // by the effective target.
       if (!callee.isRedirectingGenerative) {
@@ skipping 275 matching lines @@
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       HInstruction value = fieldValues[member];
       if (value == null) {
         // Uninitialized native fields are pre-initialized by the native
         // implementation.
         assert(invariant(
             member, isNativeUpgradeFactory || compiler.compilationFailed));
       } else {
         fields.add(member);
-        DartType type = localsHandler.substInContext(member.type);
+        ResolutionDartType type = localsHandler.substInContext(member.type);
         constructorArguments
             .add(typeBuilder.potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
-    InterfaceType type = classElement.thisType;
+    ResolutionInterfaceType type = classElement.thisType;
     TypeMask ssaType =
         new TypeMask.nonNullExact(classElement.declaration, closedWorld);
-    List<DartType> instantiatedTypes;
+    List<ResolutionDartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
-      instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
+      instantiatedTypes =
+          new List<ResolutionDartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
       // Create the runtime type information, if needed.
       bool hasRtiInput = false;
       if (backend.classNeedsRtiField(classElement)) {
         // Read the values of the type arguments and create a
         // HTypeInfoExpression to set on the newly create object.
         hasRtiInput = true;
         List<HInstruction> typeArguments = <HInstruction>[];
-        classElement.typeVariables.forEach((TypeVariableType typeVariable) {
+        classElement.typeVariables
+            .forEach((ResolutionTypeVariableType typeVariable) {
           HInstruction argument = localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
           typeArguments.add(argument);
         });
 
         HInstruction typeInfo = new HTypeInfoExpression(
             TypeInfoExpressionKind.INSTANCE,
             classElement.thisType,
             typeArguments,
             commonMasks.dynamicType);
@@ skipping 63 matching lines @@
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
       // Type variables arguments must come after the box (if there is one).
       ConstructorElement constructor =
           constructorResolvedAst.element.implementation;
       ClassElement currentClass = constructor.enclosingClass;
       if (backend.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
-        currentClass.typeVariables.forEach((TypeVariableType argument) {
+        currentClass.typeVariables
+            .forEach((ResolutionTypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
           // `localsHandler.substInContext(argument)`.
           bodyCallInputs.add(localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(argument)));
         });
       }
 
       if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining.
           tryInlineMethod(body, null, null, bodyCallInputs, function)) {
         pop();
@@ skipping 28 matching lines @@
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     var enclosing = element.enclosingElement;
     if ((element.isConstructor || element.isGenerativeConstructorBody) &&
         backend.classNeedsRti(enclosing)) {
-      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
+      enclosing.typeVariables
+          .forEach((ResolutionTypeVariableType typeVariable) {
         HParameterValue param =
             addParameter(typeVariable.element, commonMasks.nonNullType);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
       });
     }
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature signature = functionElement.functionSignature;
@@ skipping 61 matching lines @@
       if (element == backend.helpers.traceHelper) return;
       // TODO(sigmund): create a better uuid for elements.
       HConstant idConstant =
           graph.addConstantInt(element.hashCode, closedWorld);
       HConstant nameConstant = addConstantString(element.name);
       add(new HInvokeStatic(backend.helpers.traceHelper,
           <HInstruction>[idConstant, nameConstant], commonMasks.dynamicType));
     }
   }
 
-  void assertIsSubtype(
-      ast.Node node, DartType subtype, DartType supertype, String message) {
+  void assertIsSubtype(ast.Node node, ResolutionDartType subtype,
+      ResolutionDartType supertype, String message) {
     HInstruction subtypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(subtype), sourceElement);
     HInstruction supertypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(supertype), sourceElement);
     HInstruction messageInstruction = graph.addConstantString(
         new ast.DartString.literal(message), closedWorld);
     MethodElement element = helpers.assertIsSubtype;
     var inputs = <HInstruction>[
       subtypeInstruction,
       supertypeInstruction,
@@ skipping 851 matching lines @@
         new HInterceptor(receiver, commonMasks.nonNullType);
     add(interceptor);
     return interceptor;
   }
 
   HLiteralList buildLiteralList(List<HInstruction> inputs) {
     return new HLiteralList(inputs, commonMasks.extendableArrayType);
   }
 
   @override
-  void visitAs(ast.Send node, ast.Node expression, DartType type, _) {
+  void visitAs(ast.Send node, ast.Node expression, ResolutionDartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(node, element.message);
       } else {
         assert(type is MethodTypeVariableType);
         stack.add(expressionInstruction);
       }
     } else {
       HInstruction converted = typeBuilder.buildTypeConversion(
           expressionInstruction,
           localsHandler.substInContext(type),
           HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) add(converted);
       stack.add(converted);
     }
   }
 
   @override
-  void visitIs(ast.Send node, ast.Node expression, DartType type, _) {
+  void visitIs(ast.Send node, ast.Node expression, ResolutionDartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     push(buildIsNode(node, type, expressionInstruction));
   }
 
   @override
-  void visitIsNot(ast.Send node, ast.Node expression, DartType type, _) {
+  void visitIsNot(
+      ast.Send node, ast.Node expression, ResolutionDartType type, _) {
     HInstruction expressionInstruction = visitAndPop(expression);
     HInstruction instruction = buildIsNode(node, type, expressionInstruction);
     add(instruction);
     push(new HNot(instruction, commonMasks.boolType));
   }
 
   HInstruction buildIsNode(
-      ast.Node node, DartType type, HInstruction expression) {
+      ast.Node node, ResolutionDartType type, HInstruction expression) {
     type = localsHandler.substInContext(type).unaliased;
     if (type.isMalformed) {
       String message;
       if (type is MethodTypeVariableType) {
         message = "Method type variables are not reified, "
             "so they cannot be tested with an `is` expression.";
       } else {
         assert(type is MalformedType);
         ErroneousElement element = type.element;
         message = element.message;
@@ skipping 830 matching lines @@
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
     if (closedWorld.isUsedAsMixin(cls)) return true;
 
     return closedWorld.anyStrictSubclassOf(cls, (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
-  HInstruction handleListConstructor(
-      InterfaceType type, ast.Node currentNode, HInstruction newObject) {
+  HInstruction handleListConstructor(ResolutionInterfaceType type,
+      ast.Node currentNode, HInstruction newObject) {
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return newObject;
     }
     List<HInstruction> inputs = <HInstruction>[];
     type = localsHandler.substInContext(type);
-    type.typeArguments.forEach((DartType argument) {
+    type.typeArguments.forEach((ResolutionDartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, inputs, newObject);
   }
 
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
@@ skipping 89 matching lines @@
       // final target.
       ConstructorElement target = constructorDeclaration;
       while (target.isRedirectingFactory) {
         if (constructorDeclaration.redirectionDeferredPrefix != null) {
           generateIsDeferredLoadedCheckIfNeeded(
               target.redirectionDeferredPrefix, node);
         }
         target = target.immediateRedirectionTarget;
       }
     }
-    InterfaceType type = elements.getType(node);
-    InterfaceType expectedType =
+    ResolutionInterfaceType type = elements.getType(node);
+    ResolutionInterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (checkTypeVariableBounds(node, type)) return;
@@ skipping 107 matching lines @@
     if (isRedirected) {
       HInstruction checked =
           typeBuilder.potentiallyCheckOrTrustType(newInstance, type);
       if (checked != newInstance) {
         pop();
         stack.add(checked);
       }
     }
   }
 
-  void potentiallyAddTypeArguments(
-      List<HInstruction> inputs, ClassElement cls, InterfaceType expectedType,
+  void potentiallyAddTypeArguments(List<HInstruction> inputs, ClassElement cls,
+      ResolutionInterfaceType expectedType,
       {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
     assert(cls.typeVariables.length == expectedType.typeArguments.length);
-    expectedType.typeArguments.forEach((DartType argument) {
+    expectedType.typeArguments.forEach((ResolutionDartType argument) {
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement,
           sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
-  bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
+  bool checkTypeVariableBounds(
+      ast.NewExpression node, ResolutionInterfaceType type) {
     if (!compiler.options.enableTypeAssertions) return false;
 
-    Map<DartType, Set<DartType>> seenChecksMap =
-        new Map<DartType, Set<DartType>>();
+    Map<ResolutionDartType, Set<ResolutionDartType>> seenChecksMap =
+        new Map<ResolutionDartType, Set<ResolutionDartType>>();
     bool definitelyFails = false;
 
-    void addTypeVariableBoundCheck(GenericType instance, DartType typeArgument,
-        TypeVariableType typeVariable, DartType bound) {
+    void addTypeVariableBoundCheck(
+        GenericType instance,
+        ResolutionDartType typeArgument,
+        ResolutionTypeVariableType typeVariable,
+        ResolutionDartType bound) {
       if (definitelyFails) return;
 
       int subtypeRelation =
           compiler.types.computeSubtypeRelation(typeArgument, bound);
       if (subtypeRelation == Types.IS_SUBTYPE) return;
 
       String message = "Can't create an instance of malbounded type '$type': "
           "'${typeArgument}' is not a subtype of bound '${bound}' for "
           "type variable '${typeVariable}' of type "
           "${type == instance
               ? "'${type.element.thisType}'"
               : "'${instance.element.thisType}' on the supertype "
                 "'${instance}' of '${type}'"
             }.";
       if (subtypeRelation == Types.NOT_SUBTYPE) {
         generateTypeError(node, message);
         definitelyFails = true;
         return;
       } else if (subtypeRelation == Types.MAYBE_SUBTYPE) {
-        Set<DartType> seenChecks =
-            seenChecksMap.putIfAbsent(typeArgument, () => new Set<DartType>());
+        Set<ResolutionDartType> seenChecks = seenChecksMap.putIfAbsent(
+            typeArgument, () => new Set<ResolutionDartType>());
         if (!seenChecks.contains(bound)) {
           seenChecks.add(bound);
           assertIsSubtype(node, typeArgument, bound, message);
         }
       }
     }
 
     compiler.types.checkTypeVariableBounds(type, addTypeVariableBoundCheck);
     if (definitelyFails) {
       return true;
     }
-    for (InterfaceType supertype in type.element.allSupertypes) {
-      DartType instance = type.asInstanceOf(supertype.element);
+    for (ResolutionInterfaceType supertype in type.element.allSupertypes) {
+      ResolutionDartType instance = type.asInstanceOf(supertype.element);
       compiler.types
           .checkTypeVariableBounds(instance, addTypeVariableBoundCheck);
       if (definitelyFails) {
         return true;
       }
     }
     return false;
   }
 
   visitStaticSend(ast.Send node) {
@@ skipping 196 matching lines @@
       // The node itself is not a constant but we register the selector (the
       // identifier that refers to the class/typedef) as a constant.
       stack.add(addConstant(node.selector));
     } else {
       stack.add(addConstant(node));
     }
   }
 
   /// Generate the literal for [typeVariable] in the current context.
   void generateTypeVariableLiteral(
-      ast.Send node, TypeVariableType typeVariable) {
+      ast.Send node, ResolutionTypeVariableType typeVariable) {
     // GENERIC_METHODS: This provides thin support for method type variables
     // by treating them as malformed when evaluated as a literal. For full
     // support of generic methods this must be revised.
     if (typeVariable is MethodTypeVariableType) {
       generateTypeError(node, "Method type variables are not reified");
     } else {
-      DartType type = localsHandler.substInContext(typeVariable);
+      ResolutionDartType type = localsHandler.substInContext(typeVariable);
       HInstruction value = typeBuilder.analyzeTypeArgument(type, sourceElement,
           sourceInformation: sourceInformationBuilder.buildGet(node));
       pushInvokeStatic(node, helpers.runtimeTypeToString, [value],
           typeMask: commonMasks.stringType);
       pushInvokeStatic(node, helpers.createRuntimeType, [pop()]);
     }
   }
 
   /// Generate a call to a type literal.
   void generateTypeLiteralCall(ast.Send node) {
@@ skipping 138 matching lines @@
       }
     } else {
       handleNewSend(node);
     }
   }
 
   @override
   void errorNonConstantConstructorInvoke(
       ast.NewExpression node,
       Element element,
-      DartType type,
+      ResolutionDartType type,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     bulkHandleNew(node);
   }
 
   void pushInvokeDynamic(ast.Node node, Selector selector, TypeMask mask,
       List<HInstruction> arguments,
       {SourceInformation sourceInformation}) {
     // We prefer to not inline certain operations on indexables,
@@ skipping 112 matching lines @@
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
 
     var nativeBehavior = new native.NativeBehavior()
       ..sideEffects.setAllSideEffects();
 
-    DartType type = element.isConstructor
+    ResolutionDartType type = element.isConstructor
         ? element.enclosingClass.thisType
         : element.type.returnType;
     // Native behavior effects here are similar to native/behavior.dart.
     // The return type is dynamic if we don't trust js-interop type
     // declarations.
     nativeBehavior.typesReturned.add(
         compiler.options.trustJSInteropTypeAnnotations
             ? type
-            : const DynamicType());
+            : const ResolutionDynamicType());
 
     // The allocation effects include the declared type if it is native (which
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!compiler.options.trustJSInteropTypeAnnotations ||
@@ skipping 15 matching lines @@
     js.Template codeTemplate = js.js.parseForeignJS(code);
     nativeBehavior.codeTemplate = codeTemplate;
 
     return new HForeignCode(codeTemplate, commonMasks.dynamicType, inputs,
         nativeBehavior: nativeBehavior)..sourceInformation = sourceInformation;
   }
 
   void pushInvokeStatic(
       ast.Node location, MethodElement element, List<HInstruction> arguments,
       {TypeMask typeMask,
-      InterfaceType instanceType,
+      ResolutionInterfaceType instanceType,
       SourceInformation sourceInformation}) {
     assert(element.isDeclaration);
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask = TypeMaskFactory.inferredReturnTypeForElement(
           element, globalInferenceResults);
     }
     bool targetCanThrow = !closedWorld.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
     if (backend.isJsInterop(element)) {
       instruction =
           invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
       instruction = new HInvokeStatic(element, arguments, typeMask,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (currentInlinedInstantiations.isNotEmpty) {
         instruction.instantiatedTypes =
-            new List<DartType>.from(currentInlinedInstantiations);
+            new List<ResolutionDartType>.from(currentInlinedInstantiations);
       }
       instruction.sideEffects = closedWorld.getSideEffectsOfElement(element);
     }
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
@@ skipping 939 matching lines @@
       } else {
         for (ParameterElement parameter in targetOptionals) {
           loadPosition(position++, parameter);
         }
       }
     }
 
     ClassElement targetClass = targetConstructor.enclosingClass;
     if (backend.classNeedsRti(targetClass)) {
       ClassElement cls = redirectingConstructor.enclosingClass;
-      InterfaceType targetType =
+      ResolutionInterfaceType targetType =
           redirectingConstructor.computeEffectiveTargetType(cls.thisType);
       targetType = localsHandler.substInContext(targetType);
-      targetType.typeArguments.forEach((DartType argument) {
+      targetType.typeArguments.forEach((ResolutionDartType argument) {
         inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
     }
     pushInvokeStatic(node, targetConstructor.declaration, inputs);
     HInstruction value = pop();
     emitReturn(value, node);
   }
 
   /// Returns true if the [type] is a valid return type for an asynchronous
   /// function.
   ///
   /// Asynchronous functions return a `Future`, and a valid return is thus
   /// either dynamic, Object, or Future.
   ///
   /// We do not accept the internal Future implementation class.
-  bool isValidAsyncReturnType(DartType type) {
+  bool isValidAsyncReturnType(ResolutionDartType type) {
     assert(isBuildingAsyncFunction);
     // TODO(sigurdm): In an internal library a function could be declared:
     //
     // _FutureImpl foo async => 1;
     //
     // This should be valid (because the actual value returned from an async
     // function is a `_FutureImpl`), but currently false is returned in this
     // case.
     return type.isDynamic ||
         type.isObject ||
-        (type is InterfaceType && type.element == commonElements.futureClass);
+        (type is ResolutionInterfaceType &&
+            type.element == commonElements.futureClass);
   }
 
   visitReturn(ast.Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(closedWorld);
@@ skipping 59 matching lines @@
       } else {
         ast.SendSet node = definition;
         generateNonInstanceSetter(
             node, local, visitAndPop(node.arguments.first));
         pop(); // Discard value.
       }
     }
   }
 
   HInstruction setRtiIfNeeded(HInstruction object, ast.Node node) {
-    InterfaceType type = localsHandler.substInContext(elements.getType(node));
+    ResolutionInterfaceType type =
+        localsHandler.substInContext(elements.getType(node));
     if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
-    for (DartType argument in type.typeArguments) {
+    for (ResolutionDartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   visitLiteralList(ast.LiteralList node) {
     HInstruction instruction;
 
@@ skipping 411 matching lines @@
       HLiteralList keyValuePairs = buildLiteralList(listInputs);
       add(keyValuePairs);
       inputs.add(keyValuePairs);
     }
 
     assert(constructor.isFactoryConstructor);
 
     ConstructorElement functionElement = constructor;
     constructor = functionElement.effectiveTarget;
 
-    InterfaceType type = elements.getType(node);
-    InterfaceType expectedType =
+    ResolutionInterfaceType type = elements.getType(node);
+    ResolutionInterfaceType expectedType =
         functionElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     ClassElement cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
-      expectedType.typeArguments.forEach((DartType argument) {
+      expectedType.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
           constructor = helpers.mapLiteralUntypedEmptyMaker;
         } else {
@@ skipping 540 matching lines @@
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
 
       pushInvokeStatic(node, helpers.exceptionUnwrapper, [exception]);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<ast.Node> link = node.catchBlocks.nodes;
 
       void pushCondition(ast.CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
-          DartType type = elements.getType(catchBlock.type);
+          ResolutionDartType type = elements.getType(catchBlock.type);
           if (type == null) {
             reporter.internalError(catchBlock.type, 'On with no type.');
           }
           HInstruction condition =
               buildIsNode(catchBlock.type, type, unwrappedException);
           push(condition);
         } else {
           ast.VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, closedWorld);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
-            DartType type = elements.getType(declaration.type);
+            ResolutionDartType type = elements.getType(declaration.type);
             if (type == null) {
               reporter.internalError(catchBlock, 'Catch with unresolved type.');
             }
             condition = buildIsNode(declaration.type, type, unwrappedException);
             push(condition);
           }
         }
       }
 
       void visitThen() {
@@ skipping 132 matching lines @@
   visitTypeVariable(ast.TypeVariable node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitTypeVariable.');
   }
 
   /**
    * This method is invoked before inlining the body of [function] into this
    * [SsaBuilder].
    */
   void enterInlinedMethod(MethodElement function,
       ResolvedAst functionResolvedAst, List<HInstruction> compiledArguments,
-      {InterfaceType instanceType}) {
+      {ResolutionInterfaceType instanceType}) {
     AstInliningState state = new AstInliningState(
         function,
         returnLocal,
         returnType,
         resolvedAst,
         stack,
         localsHandler,
         inTryStatement,
         isCalledOnce(function),
         elementInferenceResults);
@@ skipping 306 matching lines @@
    */
   final FunctionElement function;
 
   InliningState(this.function) {
     assert(function.isImplementation);
   }
 }
 
 class AstInliningState extends InliningState {
   final Local oldReturnLocal;
-  final DartType oldReturnType;
+  final ResolutionDartType oldReturnType;
   final ResolvedAst oldResolvedAst;
   final List<HInstruction> oldStack;
   final LocalsHandler oldLocalsHandler;
   final bool inTryStatement;
   final bool allFunctionsCalledOnce;
   final GlobalTypeInferenceElementResult oldElementInferenceResults;
 
   AstInliningState(
       FunctionElement function,
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }