Prefix resolution_types with Resolution.

pkg/compiler/lib/src/ssa/kernel_impact.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 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 60 matching lines @@
   KernelAstAdapter astAdapter;
 
   KernelImpactBuilder(this.resolvedAst, this.compiler, Kernel kernel) {
     this.impactBuilder =
         new ResolutionWorldImpactBuilder('${resolvedAst.element}');
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
   }
 
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
-  DartType checkType(ir.DartType irType) {
-    DartType type = astAdapter.getDartType(irType);
+  ResolutionDartType checkType(ir.DartType irType) {
+    ResolutionDartType type = astAdapter.getDartType(irType);
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
   /// Add checked-mode type use for the parameter type and constant for the
   /// default value of [parameter].
   void handleParameter(ir.VariableDeclaration parameter) {
     checkType(parameter.type);
@@ skipping 119 matching lines @@
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral literal) {
     impactBuilder.registerConstantLiteral(new NullConstantExpression());
   }
 
   @override
   void visitListLiteral(ir.ListLiteral literal) {
     visitNodes(literal.expressions);
-    DartType elementType = checkType(literal.typeArgument);
+    ResolutionDartType elementType = checkType(literal.typeArgument);
 
     impactBuilder.registerListLiteral(new ListLiteralUse(
         compiler.commonElements.listType(elementType),
         isConstant: literal.isConst,
         isEmpty: literal.expressions.isEmpty));
   }
 
   @override
   void visitMapLiteral(ir.MapLiteral literal) {
     visitNodes(literal.entries);
-    DartType keyType = checkType(literal.keyType);
-    DartType valueType = checkType(literal.valueType);
+    ResolutionDartType keyType = checkType(literal.keyType);
+    ResolutionDartType valueType = checkType(literal.valueType);
     impactBuilder.registerMapLiteral(new MapLiteralUse(
         compiler.commonElements.mapType(keyType, valueType),
         isConstant: literal.isConst,
         isEmpty: literal.entries.isEmpty));
   }
 
   void visitMapEntry(ir.MapEntry entry) {
     visitNode(entry.key);
     visitNode(entry.value);
   }
 
   void _visitArguments(ir.Arguments arguments) {
     arguments.positional.forEach(visitNode);
     arguments.named.forEach(visitNode);
   }
 
   @override
   void visitConstructorInvocation(ir.ConstructorInvocation node) {
     handleNew(node, node.target, isConst: node.isConst);
   }
 
   void handleNew(ir.InvocationExpression node, ir.Member target,
       {bool isConst: false}) {
     _visitArguments(node.arguments);
     Element element = astAdapter.getElement(target).declaration;
     ClassElement cls = astAdapter.getElement(target.enclosingClass);
-    List<DartType> typeArguments =
+    List<ResolutionDartType> typeArguments =
         astAdapter.getDartTypes(node.arguments.types);
-    InterfaceType type = new InterfaceType(cls, typeArguments);
+    ResolutionInterfaceType type =
+        new ResolutionInterfaceType(cls, typeArguments);
     CallStructure callStructure = astAdapter.getCallStructure(node.arguments);
     impactBuilder.registerStaticUse(isConst
         ? new StaticUse.constConstructorInvoke(element, callStructure, type)
         : new StaticUse.typedConstructorInvoke(element, callStructure, type));
-    if (typeArguments.any((DartType type) => !type.isDynamic)) {
+    if (typeArguments.any((ResolutionDartType type) => !type.isDynamic)) {
       impactBuilder.registerFeature(Feature.TYPE_VARIABLE_BOUNDS_CHECK);
     }
   }
 
   @override
   void visitSuperInitializer(ir.SuperInitializer node) {
     Element target = astAdapter.getElement(node.target).declaration;
     _visitArguments(node.arguments);
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, astAdapter.getCallStructure(node.arguments)));
@@ skipping 288 matching lines @@
     Element target = astAdapter.getElement(node.target).declaration;
     impactBuilder.registerStaticUse(new StaticUse.superConstructorInvoke(
         target, astAdapter.getCallStructure(node.arguments)));
   }
 
   // TODO(johnniwinther): Make this throw and visit child nodes explicitly
   // instead to ensure that we don't visit unwanted parts of the ir.
   @override
   void defaultNode(ir.Node node) => node.visitChildren(this);
 }