Prefix resolution_types with Resolution.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
@@ skipping 248 matching lines @@
   bool get isRedirectingFactory => unsupported();
 
   computeType(Resolution resolution) => unsupported();
 
   bool get hasFunctionSignature => false;
 
   bool get hasEffectiveTarget => true;
 
   get effectiveTarget => this;
 
-  computeEffectiveTargetType(InterfaceType newType) => unsupported();
+  computeEffectiveTargetType(ResolutionInterfaceType newType) => unsupported();
 
   get definingConstructor => null;
 
   FunctionElement asFunctionElement() => this;
 
   String get message {
     return MessageTemplate.TEMPLATES[messageKind]
         .message(messageArguments)
         .toString();
   }
 
   String toString() => '<$name: $message>';
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitErroneousElement(this, arg);
   }
 
   @override
   get isEffectiveTargetMalformed {
     throw new UnsupportedError("isEffectiveTargetMalformed");
   }
 
   @override
-  List<DartType> get typeVariables => unsupported();
+  List<ResolutionDartType> get typeVariables => unsupported();
 }
 
 /// A constructor that was synthesized to recover from a compile-time error.
 class ErroneousConstructorElementX extends ErroneousElementX
     with
         PatchMixin<FunctionElement>,
         AnalyzableElementX,
         ConstantConstructorMixin
     implements ConstructorElementX {
   // TODO(ahe): Instead of subclassing [ErroneousElementX], this class should
@@ skipping 67 matching lines @@
   set _isEffectiveTargetMalformed(_) {
     throw new UnsupportedError("_isEffectiveTargetMalformed=");
   }
 
   @override
   get isEffectiveTargetMalformed {
     throw new UnsupportedError("isEffectiveTargetMalformed");
   }
 
   @override
-  void setEffectiveTarget(ConstructorElement target, InterfaceType type,
+  void setEffectiveTarget(
+      ConstructorElement target, ResolutionInterfaceType type,
       {bool isMalformed: false}) {
     throw new UnsupportedError("setEffectiveTarget");
   }
 
   @override
   void _computeSignature(Resolution resolution) {
     throw new UnsupportedError("_computeSignature");
   }
 
   @override
@@ skipping 166 matching lines @@
       Element context, DiagnosticReporter reporter) {
     return const <DiagnosticMessage>[];
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAmbiguousElement(this, arg);
   }
 
   bool get isTopLevel => false;
 
-  DynamicType get type => const DynamicType();
+  ResolutionDynamicType get type => const ResolutionDynamicType();
 }
 
 /// Element synthesized to diagnose an ambiguous import.
 class AmbiguousImportX extends AmbiguousElementX {
   AmbiguousImportX(MessageKind messageKind, Map messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : super(messageKind, messageArguments, enclosingElement, existingElement,
             newElement);
 
   List<DiagnosticMessage> computeInfos(
@@ skipping 688 matching lines @@
   PrefixElementX(
       String prefix, Element enclosing, this.firstPosition, this.deferredImport)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   bool get isTopLevel => false;
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   void forEachLocalMember(f(Element member)) => importScope.forEach(f);
 
-  DartType computeType(Resolution resolution) => const DynamicType();
+  ResolutionDartType computeType(Resolution resolution) =>
+      const ResolutionDynamicType();
 
   Token get position => firstPosition;
 
   void addImport(
       Element element, ImportElement import, DiagnosticReporter reporter) {
     importScope.addImport(this, element, import, reporter);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitPrefixElement(this, arg);
   }
 
   @override
   GetterElement get loadLibrary {
     return isDeferred ? lookupLocalMember(Identifiers.loadLibrary) : null;
   }
 
   String toString() => '$kind($name)';
 }
 
 class TypedefElementX extends ElementX
     with
         AstElementMixin,
         AnalyzableElementX,
-        TypeDeclarationElementX<TypedefType>
+        TypeDeclarationElementX<ResolutionTypedefType>
     implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type annotation which defines this typedef.
    */
-  DartType aliasCache;
+  ResolutionDartType aliasCache;
 
-  DartType get alias {
+  ResolutionDartType get alias {
     assert(invariant(this, hasBeenCheckedForCycles,
         message: "$this has not been checked for cycles."));
     return aliasCache;
   }
 
   /// [:true:] if the typedef has been checked for cyclic reference.
   bool hasBeenCheckedForCycles = false;
 
   int resolutionState = STATE_NOT_STARTED;
 
@@ skipping 11 matching lines @@
   /**
    * Function signature for a typedef of a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
-  TypedefType computeType(Resolution resolution) {
+  ResolutionTypedefType computeType(Resolution resolution) {
     if (thisTypeCache != null) return thisTypeCache;
     Typedef node = parseNode(resolution.parsingContext);
     setThisAndRawTypes(createTypeVariables(node.typeParameters));
     ensureResolved(resolution);
     return thisTypeCache;
   }
 
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveTypedef(this);
     }
   }
 
-  TypedefType createType(List<DartType> typeArguments) {
-    return new TypedefType(this, typeArguments);
+  ResolutionTypedefType createType(List<ResolutionDartType> typeArguments) {
+    return new ResolutionTypedefType(this, typeArguments);
   }
 
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Resolution resolution) {
     if (hasBeenCheckedForCycles) return;
     TypedefCyclicVisitor visitor =
         new TypedefCyclicVisitor(resolution.reporter, this);
     computeType(resolution).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
 
 // This class holds common information for a list of variable or field
 // declarations. It contains the node, and the type. A [VariableElementX]
 // forwards its [computeType] and [parseNode] methods to this class.
 class VariableList implements DeclarationSite {
   VariableDefinitions definitions;
-  DartType type;
+  ResolutionDartType type;
   final Modifiers modifiers;
   List<MetadataAnnotation> metadataInternal;
 
   VariableList(Modifiers this.modifiers);
 
   VariableList.node(VariableDefinitions node, this.type)
       : this.definitions = node,
         this.modifiers = node.modifiers {
     assert(modifiers != null);
   }
@@ skipping 15 matching lines @@
       return;
     }
     assert(metadataInternal == null);
     metadataInternal = metadata;
   }
 
   VariableDefinitions parseNode(Element element, ParsingContext parsing) {
     return definitions;
   }
 
-  DartType computeType(Element element, Resolution resolution) => type;
+  ResolutionDartType computeType(Element element, Resolution resolution) =>
+      type;
 }
 
 abstract class ConstantVariableMixin implements VariableElement {
   ConstantExpression constantCache;
 
   // TODO(johnniwinther): Update the on `constant = ...` when evaluation of
   // constant expression can handle references to unanalyzed constant variables.
   @override
   bool get hasConstant => false;
 
@@ skipping 119 matching lines @@
         }
       } else if (identical(name, identifier.source)) {
         definitionCache = initializedIdentifier;
       }
     }
     invariant(definitions, definitionCache != null,
         message: "Could not find '$name'.");
     definitionsCache = definitions;
   }
 
-  DartType computeType(Resolution resolution) {
+  ResolutionDartType computeType(Resolution resolution) {
     if (variables.type != null) return variables.type;
     // Call [parseNode] to ensure that [definitionsCache] and [initializerCache]
     // are set as a consequence of calling [computeType].
     parseNode(resolution.parsingContext);
     return variables.computeType(this, resolution);
   }
 
-  DartType get type {
+  ResolutionDartType get type {
     assert(invariant(this, variables.type != null,
         message: "Type has not been computed for $this."));
     return variables.type;
   }
 
   bool get isInstanceMember => isClassMember && !isStatic;
 
   // Note: cachedNode.beginToken will not be correct in all
   // cases, for example, for function typed parameters.
   Token get position => token;
@@ skipping 50 matching lines @@
 /// A field that was synthesized to recover from a compile-time error.
 class ErroneousFieldElementX extends ElementX
     with ConstantVariableMixin
     implements FieldElementX {
   final VariableList variables;
 
   ErroneousFieldElementX(Identifier name, Element enclosingElement)
       : variables = new VariableList(Modifiers.EMPTY)
           ..definitions = new VariableDefinitions(
               null, Modifiers.EMPTY, new NodeList.singleton(name))
-          ..type = const DynamicType(),
+          ..type = const ResolutionDynamicType(),
         super(name.source, ElementKind.FIELD, enclosingElement);
 
   VariableDefinitions get definitionsCache => variables.definitions;
 
   set definitionsCache(VariableDefinitions _) {
     throw new UnsupportedError("definitionsCache=");
   }
 
   bool get hasNode => true;
 
   VariableDefinitions get node => definitionsCache;
 
   bool get hasResolvedAst => false;
 
   ResolvedAst get resolvedAst {
     throw new UnsupportedError("resolvedAst");
   }
 
-  DynamicType get type => const DynamicType();
+  ResolutionDynamicType get type => const ResolutionDynamicType();
 
   Token get token => node.getBeginToken();
 
   get definitionCache {
     throw new UnsupportedError("definitionCache");
   }
 
   set definitionCache(_) {
     throw new UnsupportedError("definitionCache=");
   }
@@ skipping 36 matching lines @@
   AstElement get definingElement => this;
 
   void reuseElement() {
     throw new UnsupportedError("reuseElement");
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     throw new UnsupportedError("copyWithEnclosing");
   }
 
-  DartType computeType(Resolution resolution) => type;
+  ResolutionDartType computeType(Resolution resolution) => type;
 }
 
 /// [Element] for a parameter-like element.
 class FormalElementX extends ElementX
     with AstElementMixin
     implements FormalElement {
   final VariableDefinitions definitions;
   final Identifier identifier;
-  DartType typeCache;
+  ResolutionDartType typeCache;
 
   @override
-  List<DartType> get typeVariables => functionSignature.typeVariables;
+  List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
 
   /**
    * Function signature for a variable with a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    */
   FunctionSignature _functionSignatureCache;
 
   FormalElementX(ElementKind elementKind, FunctionTypedElement enclosingElement,
       this.definitions, Identifier identifier)
       : this.identifier = identifier,
         super(identifier.source, elementKind, enclosingElement);
 
   FunctionTypedElement get functionDeclaration => enclosingElement;
 
   Modifiers get modifiers => definitions.modifiers;
 
   Token get position => identifier.getBeginToken();
 
   Node parseNode(ParsingContext parsing) => definitions;
 
-  DartType computeType(Resolution resolution) {
+  ResolutionDartType computeType(Resolution resolution) {
     assert(invariant(this, type != null,
         message: "Parameter type has not been set for $this."));
     return type;
   }
 
-  DartType get type {
+  ResolutionDartType get type {
     assert(invariant(this, typeCache != null,
         message: "Parameter type has not been set for $this."));
     return typeCache;
   }
 
   FunctionSignature get functionSignature {
     assert(invariant(this, _functionSignatureCache != null,
         message: "Parameter signature has not been computed for $this."));
     return _functionSignatureCache;
   }
 
   void set functionSignature(FunctionSignature value) {
     assert(invariant(this, _functionSignatureCache == null,
         message: "Parameter signature has already been computed for $this."));
     _functionSignatureCache = value;
     typeCache = _functionSignatureCache.type;
   }
 
   bool get hasNode => true;
 
   VariableDefinitions get node => definitions;
 
-  FunctionType get functionType => type;
+  ResolutionFunctionType get functionType => type;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFormalElement(this, arg);
   }
 
   // A parameter is defined by the declaration element.
   AstElement get definingElement => declaration;
 }
 
 /// [Element] for a formal parameter.
@@ skipping 98 matching lines @@
             identifier, null);
 
   VariableDefinitions get definitions => fieldElement.node;
 
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 
   bool get isMalformed => true;
 
-  DynamicType get type => const DynamicType();
+  ResolutionDynamicType get type => const ResolutionDynamicType();
 }
 
 class AbstractFieldElementX extends ElementX
     with AbstractFieldElementCommon
     implements AbstractFieldElement {
   GetterElementX getter;
   SetterElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
-  DartType computeType(Compiler compiler) {
+  ResolutionDartType computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(ParsingContext parsing) {
     throw "internal error: AbstractFieldElement has no node";
   }
 
   Token get position {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
@@ skipping 25 matching lines @@
   accept(ElementVisitor visitor, arg) {
     return visitor.visitAbstractFieldElement(this, arg);
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 // TODO(karlklose): all these lists should have element type [FormalElement].
 class FunctionSignatureX extends FunctionSignatureCommon
     implements FunctionSignature {
-  final List<DartType> typeVariables;
+  final List<ResolutionDartType> typeVariables;
   final List<Element> requiredParameters;
   final List<Element> optionalParameters;
   final int requiredParameterCount;
   final int optionalParameterCount;
   final bool optionalParametersAreNamed;
   final List<Element> orderedOptionalParameters;
-  final FunctionType type;
+  final ResolutionFunctionType type;
   final bool hasOptionalParameters;
 
   FunctionSignatureX(
-      {this.typeVariables: const <DartType>[],
+      {this.typeVariables: const <ResolutionDartType>[],
       this.requiredParameters: const <Element>[],
       this.requiredParameterCount: 0,
       List<Element> optionalParameters: const <Element>[],
       this.optionalParameterCount: 0,
       this.optionalParametersAreNamed: false,
       this.orderedOptionalParameters: const <Element>[],
       this.type})
       : optionalParameters = optionalParameters,
         hasOptionalParameters = !optionalParameters.isEmpty;
 }
 
 abstract class BaseFunctionElementX extends ElementX
     with PatchMixin<FunctionElement>, AstElementMixin
     implements FunctionElement {
-  DartType typeCache;
+  ResolutionDartType typeCache;
   final Modifiers modifiers;
 
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FunctionSignature _functionSignatureCache;
 
   AsyncMarker asyncMarker = AsyncMarker.SYNC;
 
   BaseFunctionElementX(String name, ElementKind kind, Modifiers this.modifiers,
       Element enclosing)
@@ skipping 30 matching lines @@
   }
 
   List<ParameterElement> get parameters {
     // TODO(johnniwinther): Store the list directly, possibly by using List
     // instead of Link in FunctionSignature.
     List<ParameterElement> list = <ParameterElement>[];
     functionSignature.forEachParameter((e) => list.add(e));
     return list;
   }
 
-  FunctionType computeType(Resolution resolution) {
+  ResolutionFunctionType computeType(Resolution resolution) {
     if (typeCache != null) return typeCache;
     _computeSignature(resolution);
     assert(invariant(this, typeCache != null,
         message: "Type cache expected to be set on $this."));
     return typeCache;
   }
 
-  FunctionType get type {
+  ResolutionFunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionElement asFunctionElement() => this;
 
   @override
   Scope buildScope() => new TypeDeclarationScope(super.buildScope(), this);
 
   String toString() {
     if (isPatch) {
       return 'patch ${super.toString()}';
     } else if (isPatched) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 
   bool get isAbstract => false;
 
   // A function is defined by the implementation element.
   AstElement get definingElement => implementation;
 
   @override
-  List<DartType> get typeVariables => functionSignature.typeVariables;
+  List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
 }
 
 abstract class FunctionElementX extends BaseFunctionElementX
     with AnalyzableElementX
     implements MethodElement {
   FunctionElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
 
   MemberElement get memberContext => this;
@@ skipping 132 matching lines @@
       assert(invariant(
           this, _constantConstructor == null || _constantConstructor == value,
           message: "Constant constructor already computed for $this:"
               "Existing: $_constantConstructor, new: $value"));
       _constantConstructor = value;
     }
   }
 
   /// Returns the empty list of type variables by default.
   @override
-  List<DartType> get typeVariables => functionSignature.typeVariables;
+  List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
 }
 
 abstract class ConstructorElementX extends FunctionElementX
     with ConstantConstructorMixin, ConstructorElementCommon
     implements ConstructorElement {
   bool isRedirectingGenerativeInternal = false;
 
   ConstructorElementX(
       String name, ElementKind kind, Modifiers modifiers, Element enclosing)
       : super(name, kind, modifiers, enclosing);
@@ skipping 11 matching lines @@
   bool get isRedirectingFactory => immediateRedirectionTarget != null;
 
   // TODO(johnniwinther): This should also return true for cyclic redirecting
   // generative constructors.
   bool get isCyclicRedirection => effectiveTarget.isRedirectingFactory;
 
   bool get isDefaultConstructor => false;
 
   /// These fields are set by the post process queue when checking for cycles.
   ConstructorElement effectiveTargetInternal;
-  DartType _effectiveTargetType;
+  ResolutionDartType _effectiveTargetType;
   bool _isEffectiveTargetMalformed;
 
   bool get hasEffectiveTarget {
     if (isPatched) {
       return patch.hasEffectiveTarget;
     }
     return effectiveTargetInternal != null;
   }
 
   void setImmediateRedirectionTarget(
@@ skipping 16 matching lines @@
     return _immediateRedirectionTarget;
   }
 
   PrefixElement get redirectionDeferredPrefix {
     if (isPatched) {
       return patch.redirectionDeferredPrefix;
     }
     return _redirectionDeferredPrefix;
   }
 
-  void setEffectiveTarget(ConstructorElement target, DartType type,
+  void setEffectiveTarget(ConstructorElement target, ResolutionDartType type,
       {bool isMalformed: false}) {
     if (isPatched) {
       patch.setEffectiveTarget(target, type, isMalformed: isMalformed);
     } else {
       assert(invariant(this, target != null,
           message: 'No effective target provided for $this.'));
       assert(invariant(this, effectiveTargetInternal == null,
           message: 'Effective target has already been computed for $this.'));
       assert(invariant(this, !target.isMalformed || isMalformed,
           message: 'Effective target is not marked as malformed for $this: '
@@ skipping 11 matching lines @@
     if (isPatched) {
       return patch.effectiveTarget;
     }
     if (isRedirectingFactory) {
       assert(effectiveTargetInternal != null);
       return effectiveTargetInternal;
     }
     return this;
   }
 
-  DartType get effectiveTargetType {
+  ResolutionDartType get effectiveTargetType {
     if (isPatched) {
       return patch.effectiveTargetType;
     }
     assert(invariant(this, _effectiveTargetType != null,
         message: 'Effective target type has not yet been computed for $this.'));
     return _effectiveTargetType;
   }
 
-  DartType computeEffectiveTargetType(InterfaceType newType) {
+  ResolutionDartType computeEffectiveTargetType(
+      ResolutionInterfaceType newType) {
     if (isPatched) {
       return patch.computeEffectiveTargetType(newType);
     }
     if (!isRedirectingFactory) return newType;
     return effectiveTargetType.substByContext(newType);
   }
 
   bool get isEffectiveTargetMalformed {
     if (isPatched) {
       return patch.isEffectiveTargetMalformed;
@@ skipping 13 matching lines @@
   ClassElement get enclosingClass => enclosingElement;
 }
 
 class DeferredLoaderGetterElementX extends GetterElementX
     implements GetterElement {
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super(Identifiers.loadLibrary, Modifiers.EMPTY, prefix, false) {
-    functionSignature = new FunctionSignatureX(type: new FunctionType(this));
+    functionSignature =
+        new FunctionSignatureX(type: new ResolutionFunctionType(this));
   }
 
   bool get isClassMember => false;
 
   bool get isSynthesized => true;
 
   bool get isDeferredLoaderGetter => true;
 
   bool get isTopLevel => true;
 
@@ skipping 44 matching lines @@
           _resolvedAst.body, _resolvedAst.elements, _resolvedAst.sourceUri);
     } else {
       return new SynthesizedResolvedAst(declaration, _resolvedAst.kind);
     }
   }
 
   List<MetadataAnnotation> get metadata => constructor.metadata;
 
   bool get isInstanceMember => true;
 
-  FunctionType computeType(Resolution resolution) {
+  ResolutionFunctionType computeType(Resolution resolution) {
     DiagnosticReporter reporter = resolution.reporter;
     reporter.internalError(this, '$this.computeType.');
     return null;
   }
 
   int get sourceOffset => constructor.sourceOffset;
 
   Token get position => constructor.position;
 
   Element get outermostEnclosingMemberOrTopLevel => constructor;
@@ skipping 24 matching lines @@
             enclosing) {
     _resolvedAst = new SynthesizedResolvedAst(
         this, ResolvedAstKind.FORWARDING_CONSTRUCTOR);
   }
 
   SynthesizedConstructorElementX.forDefault(
       this.definingConstructor, Element enclosing)
       : super('', ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
             enclosing) {
     functionSignature = new FunctionSignatureX(
-        type: new FunctionType.synthesized(enclosingClass.thisType));
+        type: new ResolutionFunctionType.synthesized(enclosingClass.thisType));
     _resolvedAst =
         new SynthesizedResolvedAst(this, ResolvedAstKind.DEFAULT_CONSTRUCTOR);
   }
 
   bool get isDefaultConstructor {
     return _resolvedAst.kind == ResolvedAstKind.DEFAULT_CONSTRUCTOR;
   }
 
   FunctionExpression parseNode(ParsingContext parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   bool get hasResolvedAst => true;
 
   ResolvedAst get resolvedAst => _resolvedAst;
 
-  DartType get type {
+  ResolutionDartType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
   void _computeSignature(Resolution resolution) {
     if (hasFunctionSignature) return;
     if (definingConstructor.isMalformed) {
       functionSignature = new FunctionSignatureX(
-          type: new FunctionType.synthesized(enclosingClass.thisType));
+          type:
+              new ResolutionFunctionType.synthesized(enclosingClass.thisType));
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     definingConstructor.computeType(resolution);
     functionSignature = definingConstructor.functionSignature;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
@@ skipping 19 matching lines @@
    *
    * The raw type is the generic type base on this element in which the type
    * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
    * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
    * is the same as [thisType].
    *
    * The [rawType] field is a canonicalization of the raw type and should be
    * used to distinguish explicit and implicit uses of the [dynamic]
    * type arguments. For instance should [:List:] be the [rawType] of the
    * [:List:] class element whereas [:List<dynamic>:] should be its own
-   * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
-   * this distinction, we can print the raw type with type arguments only when
-   * the input source has used explicit type arguments.
+   * instantiation of [ResolutionInterfaceType] with [:dynamic:] as type
+   * argument. Using this distinction, we can print the raw type with type
+   * arguments only when the input source has used explicit type arguments.
    *
    * This type is computed together with [thisType] in [computeType].
    */
   T rawTypeCache;
 
   T get thisType {
     assert(invariant(this, thisTypeCache != null,
         message: 'This type has not been computed for $this'));
     return thisTypeCache;
   }
 
   T get rawType {
     assert(invariant(this, rawTypeCache != null,
         message: 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
-  T createType(List<DartType> typeArguments);
+  T createType(List<ResolutionDartType> typeArguments);
 
-  void setThisAndRawTypes(List<DartType> typeParameters) {
+  void setThisAndRawTypes(List<ResolutionDartType> typeParameters) {
     assert(invariant(this, thisTypeCache == null,
         message: "This type has already been set on $this."));
     assert(invariant(this, rawTypeCache == null,
         message: "Raw type has already been set on $this."));
     thisTypeCache = createType(typeParameters);
     if (typeParameters.isEmpty) {
       rawTypeCache = thisTypeCache;
     } else {
-      List<DartType> dynamicParameters =
-          new List.filled(typeParameters.length, const DynamicType());
+      List<ResolutionDartType> dynamicParameters =
+          new List.filled(typeParameters.length, const ResolutionDynamicType());
       rawTypeCache = createType(dynamicParameters);
     }
   }
 
-  List<DartType> get typeVariables => thisType.typeArguments;
+  List<ResolutionDartType> get typeVariables => thisType.typeArguments;
 
   /**
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
-  List<DartType> createTypeVariables(NodeList parameters) {
-    if (parameters == null) return const <DartType>[];
+  List<ResolutionDartType> createTypeVariables(NodeList parameters) {
+    if (parameters == null) return const <ResolutionDartType>[];
 
     // Create types and elements for type variable.
     Link<Node> nodes = parameters.nodes;
-    List<DartType> arguments =
+    List<ResolutionDartType> arguments =
         new List.generate(nodes.slowLength(), (int index) {
       TypeVariable node = nodes.head;
       String variableName = node.name.source;
       nodes = nodes.tail;
       TypeVariableElementX variableElement =
           new TypeVariableElementX(variableName, this, index, node);
-      TypeVariableType variableType = new TypeVariableType(variableElement);
+      ResolutionTypeVariableType variableType =
+          new ResolutionTypeVariableType(variableElement);
       variableElement.typeCache = variableType;
       return variableType;
     }, growable: false);
     return arguments;
   }
 
   bool get isResolved => resolutionState == STATE_DONE;
 
   int get resolutionState;
 }
 
 abstract class BaseClassElementX extends ElementX
     with
         AstElementMixin,
         AnalyzableElementX,
         ClassElementCommon,
-        TypeDeclarationElementX<InterfaceType>,
+        TypeDeclarationElementX<ResolutionInterfaceType>,
         PatchMixin<ClassElement>,
         ClassMemberMixin
     implements ClassElement {
   final int id;
 
-  DartType supertype;
-  Link<DartType> interfaces;
+  ResolutionDartType supertype;
+  Link<ResolutionDartType> interfaces;
   int supertypeLoadState;
   int resolutionState;
   bool isProxy = false;
   bool hasIncompleteHierarchy = false;
 
   OrderedTypeSet allSupertypesAndSelf;
 
   BaseClassElementX(String name, Element enclosing, this.id, int initialState)
       : supertypeLoadState = initialState,
         resolutionState = initialState,
         super(name, ElementKind.CLASS, enclosing);
 
   int get hashCode => id;
 
   bool get isUnnamedMixinApplication => false;
 
   @override
   bool get isEnumClass => false;
 
-  InterfaceType computeType(Resolution resolution) {
+  ResolutionInterfaceType computeType(Resolution resolution) {
     if (isPatch) {
       origin.computeType(resolution);
       thisTypeCache = origin.thisType;
       rawTypeCache = origin.rawType;
     } else if (thisTypeCache == null) {
       computeThisAndRawType(
           resolution, computeTypeParameters(resolution.parsingContext));
     }
     return thisTypeCache;
   }
 
   void computeThisAndRawType(
-      Resolution resolution, List<DartType> typeVariables) {
+      Resolution resolution, List<ResolutionDartType> typeVariables) {
     if (thisTypeCache == null) {
       if (origin == null) {
         setThisAndRawTypes(typeVariables);
       } else {
         thisTypeCache = origin.computeType(resolution);
         rawTypeCache = origin.rawType;
       }
     }
   }
 
   @override
-  InterfaceType createType(List<DartType> typeArguments) {
-    return new InterfaceType(this, typeArguments);
+  ResolutionInterfaceType createType(List<ResolutionDartType> typeArguments) {
+    return new ResolutionInterfaceType(this, typeArguments);
   }
 
-  List<DartType> computeTypeParameters(ParsingContext parsing);
+  List<ResolutionDartType> computeTypeParameters(ParsingContext parsing);
 
   bool get isObject {
     assert(invariant(this, isResolved,
         message: "isObject has not been computed for $this."));
     return supertype == null;
   }
 
   void ensureResolved(Resolution resolution) {
     if (resolutionState == STATE_NOT_STARTED) {
       resolution.resolveClass(this);
@@ skipping 87 matching lines @@
     }
     return false;
   }
 
   void setDefaultConstructor(
       FunctionElement constructor, DiagnosticReporter reporter) {
     // The default constructor, although synthetic, is part of a class' API.
     addMember(constructor, reporter);
   }
 
-  List<DartType> computeTypeParameters(ParsingContext parsing) {
+  List<ResolutionDartType> computeTypeParameters(ParsingContext parsing) {
     ClassNode node = parseNode(parsing);
     return createTypeVariables(node.typeParameters);
   }
 
   Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
 
   String toString() {
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
@@ skipping 47 matching lines @@
   bool get isEnumClass => true;
 
   @override
   Node parseNode(ParsingContext parsing) => node;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitEnumClassElement(this, arg);
   }
 
-  List<DartType> computeTypeParameters(ParsingContext parsing) =>
-      const <DartType>[];
+  List<ResolutionDartType> computeTypeParameters(ParsingContext parsing) =>
+      const <ResolutionDartType>[];
 
   List<FieldElement> get enumValues {
     assert(invariant(this, _enumValues != null,
         message: "enumValues has not been computed for $this."));
     return _enumValues;
   }
 
   void set enumValues(List<FieldElement> values) {
     assert(invariant(this, _enumValues == null,
         message: "enumValues has already been computed for $this."));
@@ skipping 215 matching lines @@
     return new SourceSpan(enclosingClass.sourcePosition.uri,
         position.charOffset, position.charEnd);
   }
 }
 
 abstract class MixinApplicationElementX extends BaseClassElementX
     with MixinApplicationElementCommon
     implements MixinApplicationElement {
   Link<ConstructorElement> constructors = new Link<ConstructorElement>();
 
-  InterfaceType mixinType;
+  ResolutionInterfaceType mixinType;
 
   MixinApplicationElementX(String name, Element enclosing, int id)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   ClassElement get mixin => mixinType != null ? mixinType.element : null;
 
   bool get isMixinApplication => true;
   bool get hasConstructor => !constructors.isEmpty;
   bool get hasLocalScopeMembers => !constructors.isEmpty;
 
@@ skipping 17 matching lines @@
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(
       FunctionElement constructor, DiagnosticReporter reporter) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
-  List<DartType> computeTypeParameters(ParsingContext parsing) {
+  List<ResolutionDartType> computeTypeParameters(ParsingContext parsing) {
     NamedMixinApplication named = node.asNamedMixinApplication();
     if (named == null) {
       throw new SpannableAssertionFailure(
           node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
     }
     return createTypeVariables(named.typeParameters);
   }
 
@@ skipping 86 matching lines @@
   bool get isSwitch => statement is SwitchStatement;
 
   String toString() => 'Target:$statement';
 }
 
 class TypeVariableElementX extends ElementX
     with AstElementMixin
     implements TypeVariableElement {
   final int index;
   final Node node;
-  TypeVariableType typeCache;
-  DartType boundCache;
+  ResolutionTypeVariableType typeCache;
+  ResolutionDartType boundCache;
 
   TypeVariableElementX(
       String name, GenericElement enclosing, this.index, this.node)
       : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   GenericElement get typeDeclaration => enclosingElement;
 
-  TypeVariableType computeType(Resolution resolution) => type;
+  ResolutionTypeVariableType computeType(Resolution resolution) => type;
 
-  TypeVariableType get type {
+  ResolutionTypeVariableType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been set on $this."));
     return typeCache;
   }
 
-  DartType get bound {
+  ResolutionDartType get bound {
     assert(invariant(this, boundCache != null,
         message: "Bound has not been set on $this."));
     return boundCache;
   }
 
   bool get hasNode => true;
 
   Node parseNode(ParsingContext parsing) => node;
 
   Token get position => node.getBeginToken();
@@ skipping 146 matching lines @@
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration,
         node,
         body,
         definingElement.treeElements,
         definingElement.compilationUnit.script.resourceUri);
   }
 }