Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../constants/constructors.dart'
     show
@@ skipping 121 matching lines @@
     if (isConst) {
       if (result.isConstant && field != null) {
         // TODO(johnniwinther): Report error if `result.constant` is `null`.
         fieldInitializers[field] = result.constant;
       } else {
         isValidAsConstant = false;
       }
     }
   }
 
-  InterfaceType getSuperOrThisLookupTarget(Node diagnosticNode,
+  ResolutionInterfaceType getSuperOrThisLookupTarget(Node diagnosticNode,
       {bool isSuperCall}) {
     if (isSuperCall) {
       // Calculate correct lookup target and constructor name.
       if (constructor.enclosingClass.isObject) {
         reporter.reportErrorMessage(
             diagnosticNode, MessageKind.SUPER_INITIALIZER_IN_OBJECT);
         isValidAsConstant = false;
       } else {
         return constructor.enclosingClass.supertype;
       }
     }
     return constructor.enclosingClass.thisType;
   }
 
   ResolutionResult resolveSuperOrThisForSend(Send node) {
     // Resolve the selector and the arguments.
     ArgumentsResult argumentsResult = visitor.inStaticContext(() {
       // TODO(johnniwinther): Remove this when [SendStructure] is used directly.
       visitor.resolveSelector(node, null);
       return visitor.resolveArguments(node.argumentsNode);
     }, inConstantInitializer: isConst);
 
     bool isSuperCall = Initializers.isSuperConstructorCall(node);
-    InterfaceType targetType =
+    ResolutionInterfaceType targetType =
         getSuperOrThisLookupTarget(node, isSuperCall: isSuperCall);
     ClassElement lookupTarget = targetType.element;
     String constructorName =
         visitor.getRedirectingThisOrSuperConstructorName(node).text;
     ConstructorElement foundConstructor =
         findConstructor(constructor.library, lookupTarget, constructorName);
 
     final String className = lookupTarget.name;
     CallStructure callStructure = argumentsResult.callStructure;
     ConstructorElement calledConstructor = verifyThatConstructorMatchesCall(
@@ skipping 26 matching lines @@
   }
 
   ConstructedConstantExpression resolveImplicitSuperConstructorSend() {
     // If the class has a super resolve the implicit super call.
     ClassElement classElement = constructor.enclosingClass;
     ClassElement superClass = classElement.superclass;
     if (!classElement.isObject) {
       assert(superClass != null);
       assert(superClass.isResolved);
 
-      InterfaceType targetType =
+      ResolutionInterfaceType targetType =
           getSuperOrThisLookupTarget(functionNode, isSuperCall: true);
       ClassElement lookupTarget = targetType.element;
       ConstructorElement calledConstructor =
           findConstructor(constructor.library, lookupTarget, '');
 
       final String className = lookupTarget.name;
       CallStructure callStructure = CallStructure.NO_ARGS;
       ConstructorElement result = verifyThatConstructorMatchesCall(
           functionNode, calledConstructor, callStructure, className,
           isImplicitSuperCall: true);
@@ skipping 257 matching lines @@
 
   Element get context => resolver.enclosingElement;
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   ConstructorResult reportAndCreateErroneousConstructorElement(
       Spannable diagnosticNode,
       ConstructorResultKind resultKind,
-      DartType type,
+      ResolutionDartType type,
       String name,
       MessageKind kind,
       Map arguments,
       {bool isError: false,
       bool missingConstructor: false,
       List<DiagnosticMessage> infos: const <DiagnosticMessage>[]}) {
     if (missingConstructor) {
       registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     } else {
       registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
     }
     DiagnosticMessage message =
         reporter.createMessage(diagnosticNode, kind, arguments);
     if (isError || inConstContext) {
       reporter.reportError(message, infos);
     } else {
       reporter.reportWarning(message, infos);
     }
     ErroneousElement error =
         new ErroneousConstructorElementX(kind, arguments, name, context);
     if (type == null) {
       type = new MalformedType(error, null);
     }
     return new ConstructorResult.forError(resultKind, error, type);
   }
 
-  ConstructorResult resolveConstructor(PrefixElement prefix, InterfaceType type,
-      Node diagnosticNode, String constructorName) {
+  ConstructorResult resolveConstructor(
+      PrefixElement prefix,
+      ResolutionInterfaceType type,
+      Node diagnosticNode,
+      String constructorName) {
     ClassElement cls = type.element;
     cls.ensureResolved(resolution);
     ConstructorElement constructor =
         findConstructor(context.library, cls, constructorName);
     if (constructor == null) {
       MessageKind kind = constructorName.isEmpty
           ? MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR
           : MessageKind.CANNOT_FIND_CONSTRUCTOR;
       return reportAndCreateErroneousConstructorElement(
           diagnosticNode,
@@ skipping 79 matching lines @@
             {'node': diagnosticNode});
       }
     }
     resolver.registry.setType(expression, result.type);
     return result;
   }
 
   ConstructorResult visitTypeAnnotation(TypeAnnotation node) {
     // This is not really resolving a type-annotation, but the name of the
     // constructor. Therefore we allow deferred types.
-    DartType type = resolver.resolveTypeAnnotation(node,
+    ResolutionDartType type = resolver.resolveTypeAnnotation(node,
         malformedIsError: inConstContext,
         deferredIsMalformed: false,
         registerCheckedModeCheck: false);
     Send send = node.typeName.asSend();
     PrefixElement prefix;
     if (send != null) {
       // The type name is of the form [: prefix . identifier :].
       String name = send.receiver.asIdentifier().source;
       Element element = lookupInScope(reporter, send, resolver.scope, name);
       if (element != null && element.isPrefix) {
@@ skipping 110 matching lines @@
     if (error is! ErroneousElementX) {
       // Parser error. The error has already been reported.
       error = new ErroneousConstructorElementX(
           MessageKind.NOT_A_TYPE, {'node': node}, error.name, error);
       registry.registerFeature(Feature.THROW_RUNTIME_ERROR);
     }
     return new ConstructorResult.forError(ConstructorResultKind.INVALID_TYPE,
         error, new MalformedType(error, null));
   }
 
-  ConstructorResult constructorResultForType(Node node, DartType type,
+  ConstructorResult constructorResultForType(Node node, ResolutionDartType type,
       {PrefixElement prefix}) {
     String name = type.name;
     if (type.isTypeVariable) {
       return reportAndCreateErroneousConstructorElement(
           node,
           ConstructorResultKind.INVALID_TYPE,
           type,
           name,
           MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
           {'typeVariableName': name});
@@ skipping 48 matching lines @@
   /// The kind of the found constructor.
   final ConstructorResultKind kind;
 
   /// The currently found element. Since [ConstructorResult] is used for partial
   /// results, this might be a [PrefixElement], a [ClassElement], a
   /// [ConstructorElement] or in the negative cases an [ErroneousElement].
   final Element element;
 
   /// The type of the new expression. For instance `Foo<String>` in
   /// `new prefix.Foo<String>.constructorName()`.
-  final DartType type;
+  final ResolutionDartType type;
 
   /// Creates a fully resolved constructor access where [element] is resolved
   /// to a constructor and [type] to an interface type.
   ConstructorResult(this.kind, this.prefix, ConstructorElement this.element,
-      InterfaceType this.type);
+      ResolutionInterfaceType this.type);
 
   /// Creates a fully resolved constructor access where [element] is an
   /// [ErroneousElement].
   // TODO(johnniwinther): Do we still need the prefix for cases like
   // `new deferred.Class.unresolvedConstructor()` ?
   ConstructorResult.forError(
       this.kind, ErroneousElement this.element, this.type)
       : prefix = null;
 
   /// Creates a constructor access that is partially resolved to a prefix. For
@@ skipping 44 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }