Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/send_structure.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.send_structure;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 94 matching lines @@
 
   @override
   SendStructureKind get kind => SendStructureKind.LOGICAL_OR;
 
   String toString() => '||';
 }
 
 /// The structure for a [Send] of the form `a is T`.
 class IsStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is tested against.
-  final DartType type;
+  final ResolutionDartType type;
 
   IsStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitIs(node, node.receiver, type, arg);
   }
 
   @override
   SendStructureKind get kind => SendStructureKind.IS;
 
   String toString() => 'is $type';
 }
 
 /// The structure for a [Send] of the form `a is! T`.
 class IsNotStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is tested against.
-  final DartType type;
+  final ResolutionDartType type;
 
   IsNotStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitIsNot(node, node.receiver, type, arg);
   }
 
   @override
   SendStructureKind get kind => SendStructureKind.IS_NOT;
 
   String toString() => 'is! $type';
 }
 
 /// The structure for a [Send] of the form `a as T`.
 class AsStructure<R, A> implements SendStructure<R, A> {
   /// The type that the expression is cast to.
-  final DartType type;
+  final ResolutionDartType type;
 
   AsStructure(this.type);
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitAs(node, node.receiver, type, arg);
   }
 
   @override
   SendStructureKind get kind => SendStructureKind.AS;
 
@@ skipping 1947 matching lines @@
           if (constructor.isEffectiveTargetMalformed) {
             return visitor.visitUnresolvedRedirectingFactoryConstructorInvoke(
                 node,
                 semantics.element,
                 semantics.type,
                 node.send.argumentsNode,
                 callStructure,
                 arg);
           }
           ConstructorElement effectiveTarget = constructor.effectiveTarget;
-          InterfaceType effectiveTargetType =
+          ResolutionInterfaceType effectiveTargetType =
               constructor.computeEffectiveTargetType(semantics.type);
           if (callStructure
               .signatureApplies(effectiveTarget.functionSignature)) {
             return visitor.visitRedirectingFactoryConstructorInvoke(
                 node,
                 semantics.element,
                 semantics.type,
                 effectiveTarget,
                 effectiveTargetType,
                 node.send.argumentsNode,
@@ skipping 103 matching lines @@
   LateConstInvokeStructure(this.elements);
 
   @override
   NewStructureKind get kind => NewStructureKind.LATE_CONST;
 
   /// Convert this new structure into a regular new structure using the data
   /// available in [elements].
   NewStructure resolve(NewExpression node) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
-    DartType type = elements.getType(node);
+    ResolutionDartType type = elements.getType(node);
     ConstantExpression constant = elements.getConstant(node);
     if (element.isMalformed ||
         constant == null ||
         constant.kind == ConstantExpressionKind.ERRONEOUS) {
       // This is a non-constant constant constructor invocation, like
       // `const Const(method())`.
       return new NewInvokeStructure(
           new ConstructorAccessSemantics(
               ConstructorAccessKind.NON_CONSTANT_CONSTRUCTOR, element, type),
           selector);
@@ skipping 16 matching lines @@
           throw new SpannableAssertionFailure(
               node, "Unexpected constant kind $kind: ${constant.toDartText()}");
       }
       return new ConstInvokeStructure(kind, constant);
     }
   }
 
   R dispatch(SemanticSendVisitor<R, A> visitor, NewExpression node, A arg) {
     Element element = elements[node.send];
     Selector selector = elements.getSelector(node.send);
-    DartType type = elements.getType(node);
+    ResolutionDartType type = elements.getType(node);
     ConstantExpression constant = elements.getConstant(node);
     if (element.isMalformed ||
         constant == null ||
         constant.kind == ConstantExpressionKind.ERRONEOUS) {
       // This is a non-constant constant constructor invocation, like
       // `const Const(method())`.
       return visitor.errorNonConstantConstructorInvoke(node, element, type,
           node.send.argumentsNode, selector.callStructure, arg);
     } else {
       ConstantInvokeKind kind;
@@ skipping 178 matching lines @@
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitFieldInitializer(
         node, field, node.arguments.single, arg);
   }
 }
 
 class SuperConstructorInvokeStructure<R, A> extends InitializerStructure<R, A> {
   final Send node;
   final ConstructorElement constructor;
-  final InterfaceType type;
+  final ResolutionInterfaceType type;
   final CallStructure callStructure;
 
   SuperConstructorInvokeStructure(
       this.node, this.constructor, this.type, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitSuperConstructorInvoke(
         node, constructor, type, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }
 
 class ImplicitSuperConstructorInvokeStructure<R, A>
     extends InitializerStructure<R, A> {
   final FunctionExpression node;
   final ConstructorElement constructor;
-  final InterfaceType type;
+  final ResolutionInterfaceType type;
 
   ImplicitSuperConstructorInvokeStructure(
       this.node, this.constructor, this.type);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitImplicitSuperConstructorInvoke(
         node, constructor, type, arg);
   }
 
   bool get isConstructorInvoke => true;
 }
 
 class ThisConstructorInvokeStructure<R, A> extends InitializerStructure<R, A> {
   final Send node;
   final ConstructorElement constructor;
   final CallStructure callStructure;
 
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }