Prefix resolution_types with Resolution.

pkg/compiler/lib/src/kernel/kernel.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 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/verifier.dart' show CheckParentPointers;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart'
     show ConstantExpression, TypeConstantExpression;
 import '../elements/resolution_types.dart'
-    show DartType, FunctionType, InterfaceType, TypeKind, TypeVariableType;
+    show
+        ResolutionDartType,
+        ResolutionFunctionType,
+        ResolutionInterfaceType,
+        ResolutionTypeKind,
+        ResolutionTypeVariableType;
 import '../diagnostics/messages.dart' show MessageKind;
 import '../diagnostics/spannable.dart' show Spannable;
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Element,
         ExportElement,
         FieldElement,
         FunctionElement,
@@ skipping 260 matching lines @@
       for (ir.Field field in remainingFields) {
         if (field.initializer == null) {
           field.initializer = new ir.NullLiteral()..parent = field;
         }
       }
     }
   }
 
   bool hasHierarchyProblem(ClassElement cls) => cls.hasIncompleteHierarchy;
 
-  ir.InterfaceType interfaceTypeToIr(InterfaceType type) {
+  ir.InterfaceType interfaceTypeToIr(ResolutionInterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.rawType;
     } else {
       return new ir.InterfaceType(cls, typesToIr(type.typeArguments));
     }
   }
 
-  ir.Supertype supertypeToIr(InterfaceType type) {
+  ir.Supertype supertypeToIr(ResolutionInterfaceType type) {
     ir.Class cls = classToIr(type.element);
     if (type.typeArguments.isEmpty) {
       return cls.asRawSupertype;
     } else {
       return new ir.Supertype(cls, typesToIr(type.typeArguments));
     }
   }
 
-  ir.FunctionType functionTypeToIr(FunctionType type) {
+  ir.FunctionType functionTypeToIr(ResolutionFunctionType type) {
     List<ir.TypeParameter> typeParameters = <ir.TypeParameter>[];
     int requiredParameterCount = type.parameterTypes.length;
     List<ir.DartType> positionalParameters =
         new List<ir.DartType>.from(typesToIr(type.parameterTypes))
           ..addAll(typesToIr(type.optionalParameterTypes));
     List<ir.NamedType> namedParameters = new List<ir.NamedType>.generate(
         type.namedParameters.length,
         (i) => new ir.NamedType(
             type.namedParameters[i], typeToIr(type.namedParameterTypes[i])));
     ir.DartType returnType = typeToIr(type.returnType);
 
     return new ir.FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
         typeParameters: typeParameters,
         requiredParameterCount: requiredParameterCount);
   }
 
-  ir.TypeParameterType typeVariableTypeToIr(TypeVariableType type) {
+  ir.TypeParameterType typeVariableTypeToIr(ResolutionTypeVariableType type) {
     return new ir.TypeParameterType(typeVariableToIr(type.element));
   }
 
-  List<ir.DartType> typesToIr(List<DartType> types) {
+  List<ir.DartType> typesToIr(List<ResolutionDartType> types) {
     List<ir.DartType> result = new List<ir.DartType>(types.length);
     for (int i = 0; i < types.length; i++) {
       result[i] = typeToIr(types[i]);
     }
     return result;
   }
 
-  List<ir.Supertype> supertypesToIr(List<DartType> types) {
+  List<ir.Supertype> supertypesToIr(List<ResolutionDartType> types) {
     List<ir.Supertype> result = new List<ir.Supertype>(types.length);
     for (int i = 0; i < types.length; i++) {
       result[i] = supertypeToIr(types[i]);
     }
     return result;
   }
 
-  ir.DartType typeToIr(DartType type) {
+  ir.DartType typeToIr(ResolutionDartType type) {
     switch (type.kind) {
-      case TypeKind.FUNCTION:
+      case ResolutionTypeKind.FUNCTION:
         return functionTypeToIr(type);
 
-      case TypeKind.INTERFACE:
+      case ResolutionTypeKind.INTERFACE:
         return interfaceTypeToIr(type);
 
-      case TypeKind.TYPEDEF:
+      case ResolutionTypeKind.TYPEDEF:
         type.computeUnaliased(compiler.resolution);
         return typeToIr(type.unaliased);
 
-      case TypeKind.TYPE_VARIABLE:
+      case ResolutionTypeKind.TYPE_VARIABLE:
         return typeVariableTypeToIr(type);
 
-      case TypeKind.MALFORMED_TYPE:
+      case ResolutionTypeKind.MALFORMED_TYPE:
         return const ir.InvalidType();
 
-      case TypeKind.DYNAMIC:
+      case ResolutionTypeKind.DYNAMIC:
         return const ir.DynamicType();
 
-      case TypeKind.VOID:
+      case ResolutionTypeKind.VOID:
         return const ir.VoidType();
     }
   }
 
   ir.DartType typeLiteralToIr(TypeConstantExpression constant) {
     return typeToIr(constant.type);
   }
 
   void setParent(ir.Member member, Element element) {
     if (element.isLocal) {
@@ skipping 101 matching lines @@
   /// [factoryTypeParameters]. This serves as a local scope for type variables
   /// resolved inside the factory.
   ///
   /// This method solves the problem that a factory method really is a generic
   /// method that has its own type parameters, one for each type parameter in
   /// the enclosing class.
   void beginFactoryScope(FunctionElement function) {
     assert(factoryTypeParameters.isEmpty);
     if (!function.isFactoryConstructor) return;
     ClassElement cls = function.enclosingClass;
-    for (DartType type in cls.typeVariables) {
+    for (ResolutionDartType type in cls.typeVariables) {
       if (type.isTypeVariable) {
         TypeVariableElement variable = type.element;
         factoryTypeParameters[variable] =
             new ir.TypeParameter(variable.name, null);
       }
     }
-    for (DartType type in cls.typeVariables) {
+    for (ResolutionDartType type in cls.typeVariables) {
       if (type.isTypeVariable) {
         TypeVariableElement variable = type.element;
         factoryTypeParameters[variable].bound = typeToIr(variable.bound);
       }
     }
   }
 
   /// Ends the local scope started by [beginFactoryScope].
   void endFactoryScope(FunctionElement function) {
     factoryTypeParameters.clear();
@@ skipping 58 matching lines @@
         } else {
           FunctionElement method = variable.typeDeclaration;
           parameter.parent = functionToIr(method).function;
         }
         parameter.bound = typeToIr(variable.bound);
       });
       return parameter;
     });
   }
 
-  List<ir.TypeParameter> typeVariablesToIr(List<DartType> variables) {
+  List<ir.TypeParameter> typeVariablesToIr(List<ResolutionDartType> variables) {
     List<ir.TypeParameter> result =
         new List<ir.TypeParameter>(variables.length);
     for (int i = 0; i < variables.length; i++) {
-      TypeVariableType type = variables[i];
+      ResolutionTypeVariableType type = variables[i];
       result[i] = typeVariableToIr(type.element);
     }
     return result;
   }
 
   ir.TreeNode elementToIr(Element element) {
     if (element.isLibrary) return libraryToIr(element);
     if (element.isClass) return classToIr(element);
     if (element.isFunction || element.isAccessor) return functionToIr(element);
     if (element.isField) return fieldToIr(element);
     throw "unhandled element: $element";
   }
 
   void debugMessage(Spannable spannable, String message) {
     compiler.reporter
         .reportHintMessage(spannable, MessageKind.GENERIC, {'text': message});
   }
 
   void internalError(Spannable spannable, String message) {
     compiler.reporter.internalError(spannable, message);
     throw message;
   }
 
   forEachLibraryElement(f(LibraryElement library)) {
     return compiler.libraryLoader.libraries.forEach(f);
   }
 
   ConstructorTarget computeEffectiveTarget(
-      ConstructorElement constructor, DartType type) {
+      ConstructorElement constructor, ResolutionDartType type) {
     constructor = constructor.implementation;
     Set<ConstructorElement> seen = new Set<ConstructorElement>();
     functionToIr(constructor);
     while (constructor != constructor.effectiveTarget) {
       type = constructor.computeEffectiveTargetType(type);
       if (constructor.isGenerativeConstructor) break;
       if (!seen.add(constructor)) break;
       constructor = constructor.effectiveTarget.implementation;
       if (isSyntheticError(constructor)) break;
       functionToIr(constructor);
@@ skipping 146 matching lines @@
     return getDartCoreMethod('_genericNoSuchMethod');
   }
 
   ir.Constructor getFallThroughErrorConstructor() {
     return getDartCoreConstructor('FallThroughError', '');
   }
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
-  final DartType type;
+  final ResolutionDartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }