Prefix resolution_types with Resolution.

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 744 matching lines @@
   bool get isTopLevel => false;
 
   @override
   bool get isStatic => true;
 
   @override
   bool get isClassMember => true;
 }
 
 abstract class TypedElementMixin implements DeserializedElementZ, TypedElement {
-  DartType _type;
+  ResolutionDartType _type;
 
   @override
-  DartType get type {
+  ResolutionDartType get type {
     if (_type == null) {
       _type = _decoder.getType(Key.TYPE);
     }
     return _type;
   }
 
   @override
-  DartType computeType(Resolution resolution) => type;
+  ResolutionDartType computeType(Resolution resolution) => type;
 }
 
 abstract class ParametersMixin
     implements DeserializedElementZ, FunctionTypedElement {
   FunctionSignature _functionSignature;
   List<ParameterElement> _parameters;
 
   bool get hasFunctionSignature => true;
 
   @override
   FunctionSignature get functionSignature {
     if (_functionSignature == null) {
       List<Element> requiredParameters = [];
       List<Element> optionalParameters = [];
       List orderedOptionalParameters = [];
       int requiredParameterCount = 0;
       int optionalParameterCount = 0;
       bool optionalParametersAreNamed = false;
-      List<DartType> parameterTypes = <DartType>[];
-      List<DartType> optionalParameterTypes = <DartType>[];
+      List<ResolutionDartType> parameterTypes = <ResolutionDartType>[];
+      List<ResolutionDartType> optionalParameterTypes = <ResolutionDartType>[];
       for (ParameterElement parameter in parameters) {
         if (parameter.isOptional) {
           optionalParameterCount++;
           optionalParameters.add(parameter);
           orderedOptionalParameters.add(parameter);
           if (parameter.isNamed) {
             optionalParametersAreNamed = true;
           } else {
             optionalParameterTypes.add(parameter.type);
           }
         } else {
           requiredParameterCount++;
           requiredParameters.add(parameter);
           parameterTypes.add(parameter.type);
         }
       }
       List<String> namedParameters = const <String>[];
-      List<DartType> namedParameterTypes = const <DartType>[];
+      List<ResolutionDartType> namedParameterTypes =
+          const <ResolutionDartType>[];
       if (optionalParametersAreNamed) {
         namedParameters = <String>[];
-        namedParameterTypes = <DartType>[];
+        namedParameterTypes = <ResolutionDartType>[];
         orderedOptionalParameters.sort((Element a, Element b) {
           return a.name.compareTo(b.name);
         });
         for (ParameterElement parameter in orderedOptionalParameters) {
           namedParameters.add(parameter.name);
           namedParameterTypes.add(parameter.type);
         }
       }
-      List<DartType> typeVariables =
+      List<ResolutionDartType> typeVariables =
           _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
 
-      FunctionType type = new FunctionType(
+      ResolutionFunctionType type = new ResolutionFunctionType(
           this,
           _decoder.getType(Key.RETURN_TYPE),
           parameterTypes,
           optionalParameterTypes,
           namedParameters,
           namedParameterTypes);
       _functionSignature = new FunctionSignatureX(
           typeVariables: typeVariables,
           requiredParameters: requiredParameters,
           requiredParameterCount: requiredParameterCount,
@@ skipping 19 matching lines @@
   @override
   FunctionElement asFunctionElement() => this;
 
   @override
   bool get isExternal {
     return _decoder.getBool(Key.IS_EXTERNAL,
         isOptional: true, defaultValue: false);
   }
 
   @override
-  List<DartType> get typeVariables => functionSignature.typeVariables;
+  List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
 }
 
 abstract class ClassElementMixin
     implements ElementZ, ClassElement, class_members.ClassMemberMixin {
   bool _isResolved = false;
 
-  InterfaceType _createType(List<DartType> typeArguments) {
-    return new InterfaceType(this, typeArguments);
+  ResolutionInterfaceType _createType(List<ResolutionDartType> typeArguments) {
+    return new ResolutionInterfaceType(this, typeArguments);
   }
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
   bool get hasConstructor => _unsupported('hasConstructor');
 
   @override
   bool get hasIncompleteHierarchy => _unsupported('hasIncompleteHierarchy');
@@ skipping 31 matching lines @@
 }
 
 class ClassElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixinZ,
         ClassElementCommon,
         class_members.ClassMemberMixin,
         ContainerMixin,
         LibraryMemberMixin,
-        TypeDeclarationMixin<InterfaceType>,
+        TypeDeclarationMixin<ResolutionInterfaceType>,
         ClassElementMixin
     implements ClassElement {
   bool _isObject;
-  DartType _supertype;
+  ResolutionDartType _supertype;
   OrderedTypeSet _allSupertypesAndSelf;
-  Link<DartType> _interfaces;
-  FunctionType _callType;
+  Link<ResolutionDartType> _interfaces;
+  ResolutionFunctionType _callType;
 
   ClassElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
-  List<DartType> _getTypeVariables() {
+  List<ResolutionDartType> _getTypeVariables() {
     return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
   }
 
   void _ensureSuperHierarchy() {
     if (_interfaces == null) {
-      InterfaceType supertype =
+      ResolutionInterfaceType supertype =
           _decoder.getType(Key.SUPERTYPE, isOptional: true);
       if (supertype == null) {
         _isObject = true;
         _allSupertypesAndSelf = new OrderedTypeSet.singleton(thisType);
-        _interfaces = const Link<DartType>();
+        _interfaces = const Link<ResolutionDartType>();
       } else {
         _isObject = false;
         _interfaces =
             toLink(_decoder.getTypes(Key.INTERFACES, isOptional: true));
-        List<InterfaceType> mixins =
+        List<ResolutionInterfaceType> mixins =
             _decoder.getTypes(Key.MIXINS, isOptional: true);
-        for (InterfaceType mixin in mixins) {
+        for (ResolutionInterfaceType mixin in mixins) {
           MixinApplicationElement mixinElement =
               new UnnamedMixinApplicationElementZ(this, supertype, mixin);
           supertype = mixinElement.thisType
               .subst(typeVariables, mixinElement.typeVariables);
         }
         _supertype = supertype;
         _allSupertypesAndSelf = new OrderedTypeSetBuilder(this)
             .createOrderedTypeSet(_supertype, _interfaces);
         _callType = _decoder.getType(Key.CALL_TYPE, isOptional: true);
       }
     }
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitClassElement(this, arg);
   }
 
   @override
-  DartType get supertype {
+  ResolutionDartType get supertype {
     _ensureSuperHierarchy();
     return _supertype;
   }
 
   @override
   bool get isAbstract => _decoder.getBool(Key.IS_ABSTRACT);
 
   @override
   bool get isObject {
     _ensureSuperHierarchy();
     return _isObject;
   }
 
   @override
   OrderedTypeSet get allSupertypesAndSelf {
     _ensureSuperHierarchy();
     return _allSupertypesAndSelf;
   }
 
   @override
-  Link<DartType> get interfaces {
+  Link<ResolutionDartType> get interfaces {
     _ensureSuperHierarchy();
     return _interfaces;
   }
 
   @override
   bool get isProxy => _decoder.getBool(Key.IS_PROXY);
 
   @override
   bool get isInjected => _decoder.getBool(Key.IS_INJECTED);
 
   @override
   bool get isUnnamedMixinApplication => false;
 
   @override
-  FunctionType get callType {
+  ResolutionFunctionType get callType {
     _ensureSuperHierarchy();
     // TODO(johnniwinther): Why can't this always be computed in ensureResolved?
     return _callType;
   }
 }
 
 abstract class MixinApplicationElementMixin
     implements ElementZ, MixinApplicationElement {
   @override
   bool get isMixinApplication => true;
 
   @override
   ClassElement get mixin => mixinType.element;
 }
 
 class NamedMixinApplicationElementZ extends ClassElementZ
     with MixinApplicationElementMixin {
   Link<Element> _constructors;
-  InterfaceType _mixinType;
+  ResolutionInterfaceType _mixinType;
 
   NamedMixinApplicationElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
-  InterfaceType get mixinType => _mixinType ??= _decoder.getType(Key.MIXIN);
+  ResolutionInterfaceType get mixinType =>
+      _mixinType ??= _decoder.getType(Key.MIXIN);
 
   @override
   ClassElement get subclass => null;
 }
 
 class UnnamedMixinApplicationElementZ extends ElementZ
     with
         ClassElementCommon,
         ClassElementMixin,
         class_members.ClassMemberMixin,
-        TypeDeclarationMixin<InterfaceType>,
+        TypeDeclarationMixin<ResolutionInterfaceType>,
         AnalyzableElementMixin,
         AstElementMixinZ,
         MixinApplicationElementCommon,
         MixinApplicationElementMixin {
   final String name;
   final ClassElement subclass;
-  final InterfaceType _supertypeBase;
-  final InterfaceType _mixinBase;
-  InterfaceType _supertype;
-  Link<DartType> _interfaces;
+  final ResolutionInterfaceType _supertypeBase;
+  final ResolutionInterfaceType _mixinBase;
+  ResolutionInterfaceType _supertype;
+  Link<ResolutionDartType> _interfaces;
   OrderedTypeSet _allSupertypesAndSelf;
   Link<ConstructorElement> _constructors;
 
-  UnnamedMixinApplicationElementZ(
-      this.subclass, InterfaceType supertype, InterfaceType mixin)
+  UnnamedMixinApplicationElementZ(this.subclass,
+      ResolutionInterfaceType supertype, ResolutionInterfaceType mixin)
       : this._supertypeBase = supertype,
         this._mixinBase = mixin,
         this.name = "${supertype.name}+${mixin.name}";
 
   @override
   CompilationUnitElement get compilationUnit => subclass.compilationUnit;
 
   @override
   bool get isTopLevel => true;
 
@@ skipping 16 matching lines @@
               constructor, ResolvedAstKind.FORWARDING_CONSTRUCTOR);
           builder.addLast(constructor);
         }
       }
       _constructors = builder.toLink();
     }
     return _constructors;
   }
 
   @override
-  List<DartType> _getTypeVariables() {
+  List<ResolutionDartType> _getTypeVariables() {
     // Create synthetic type variables for the mixin application.
-    List<DartType> typeVariables = <DartType>[];
+    List<ResolutionDartType> typeVariables = <ResolutionDartType>[];
     int index = 0;
-    for (TypeVariableType type in subclass.typeVariables) {
+    for (ResolutionTypeVariableType type in subclass.typeVariables) {
       SyntheticTypeVariableElementZ typeVariableElement =
           new SyntheticTypeVariableElementZ(this, index, type.name);
-      TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
+      ResolutionTypeVariableType typeVariable =
+          new ResolutionTypeVariableType(typeVariableElement);
       typeVariables.add(typeVariable);
       index++;
     }
     // Setup bounds on the synthetic type variables.
-    for (TypeVariableType type in subclass.typeVariables) {
-      TypeVariableType typeVariable = typeVariables[type.element.index];
+    for (ResolutionTypeVariableType type in subclass.typeVariables) {
+      ResolutionTypeVariableType typeVariable =
+          typeVariables[type.element.index];
       SyntheticTypeVariableElementZ typeVariableElement = typeVariable.element;
       typeVariableElement._type = typeVariable;
       typeVariableElement._bound =
           type.element.bound.subst(typeVariables, subclass.typeVariables);
     }
     return typeVariables;
   }
 
   @override
-  InterfaceType get supertype {
+  ResolutionInterfaceType get supertype {
     if (_supertype == null) {
       // Substitute the type variables in [_supertypeBase] provided by
       // [_subclass] with the type variables in this unnamed mixin application.
       //
       // For instance
       //    class S<S.T> {}
       //    class M<M.T> {}
       //    class C<C.T> extends S<C.T> with M<C.T> {}
       // the unnamed mixin application should be
       //    abstract class S+M<S+M.T> extends S<S+M.T> implements M<S+M.T> {}
       // but the supertype is provided as S<C.T> and we need to substitute S+M.T
       // for C.T.
       _supertype = _supertypeBase.subst(typeVariables, subclass.typeVariables);
     }
     return _supertype;
   }
 
   @override
-  Link<DartType> get interfaces {
+  Link<ResolutionDartType> get interfaces {
     if (_interfaces == null) {
       // Substitute the type variables in [_mixinBase] provided by
       // [_subclass] with the type variables in this unnamed mixin application.
       //
       // For instance
       //    class S<S.T> {}
       //    class M<M.T> {}
       //    class C<C.T> extends S<C.T> with M<C.T> {}
       // the unnamed mixin application should be
       //    abstract class S+M<S+M.T> extends S<S+M.T> implements M<S+M.T> {}
       // but the mixin is provided as M<C.T> and we need to substitute S+M.T
       // for C.T.
-      _interfaces = const Link<DartType>()
+      _interfaces = const Link<ResolutionDartType>()
           .prepend(_mixinBase.subst(typeVariables, subclass.typeVariables));
     }
     return _interfaces;
   }
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMixinApplicationElement(this, arg);
   }
 
@@ skipping 12 matching lines @@
   @override
   bool get isObject => false;
 
   @override
   bool get isProxy => false;
 
   @override
   LibraryElement get library => enclosingElement.library;
 
   @override
-  InterfaceType get mixinType => interfaces.head;
+  ResolutionInterfaceType get mixinType => interfaces.head;
 
   @override
   int get sourceOffset => subclass.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => subclass.sourcePosition;
 }
 
 class EnumClassElementZ extends ClassElementZ implements EnumClassElement {
   List<FieldElement> _enumValues;
@@ skipping 92 matching lines @@
   @override
   bool get isRedirectingFactory => false;
 
   @override
   bool get isRedirectingGenerative => false;
 
   @override
   PrefixElement get redirectionDeferredPrefix => null;
 
   @override
-  InterfaceType computeEffectiveTargetType(InterfaceType newType) => newType;
+  ResolutionInterfaceType computeEffectiveTargetType(
+          ResolutionInterfaceType newType) =>
+      newType;
 }
 
 class GenerativeConstructorElementZ extends ConstructorElementZ {
   GenerativeConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.GENERATIVE_CONSTRUCTOR;
 
   @override
   bool get isRedirectingGenerative => _decoder.getBool(Key.IS_REDIRECTING);
@@ skipping 18 matching lines @@
 }
 
 class FactoryConstructorElementZ extends ConstructorElementZ {
   FactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 }
 
 class RedirectingFactoryConstructorElementZ extends ConstructorElementZ {
-  DartType _effectiveTargetType;
+  ResolutionDartType _effectiveTargetType;
   ConstructorElement _immediateRedirectionTarget;
   PrefixElement _redirectionDeferredPrefix;
   bool _effectiveTargetIsMalformed;
 
   RedirectingFactoryConstructorElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.FACTORY_CONSTRUCTOR;
 
   @override
@@ skipping 20 matching lines @@
     return _effectiveTargetIsMalformed;
   }
 
   @override
   ConstructorElement get effectiveTarget {
     _ensureEffectiveTarget();
     return _effectiveTarget;
   }
 
   @override
-  DartType computeEffectiveTargetType(InterfaceType newType) {
+  ResolutionDartType computeEffectiveTargetType(
+      ResolutionInterfaceType newType) {
     _ensureEffectiveTarget();
     return _effectiveTargetType.substByContext(newType);
   }
 
   void _ensureRedirection() {
     if (_immediateRedirectionTarget == null) {
       _immediateRedirectionTarget =
           _decoder.getElement(Key.IMMEDIATE_REDIRECTION_TARGET);
       _redirectionDeferredPrefix =
           _decoder.getElement(Key.PREFIX, isOptional: true);
@@ skipping 31 matching lines @@
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitConstructorElement(this, arg);
   }
 
   @override
   AsyncMarker get asyncMarker => AsyncMarker.SYNC;
 
   @override
-  InterfaceType computeEffectiveTargetType(InterfaceType newType) {
+  ResolutionInterfaceType computeEffectiveTargetType(
+      ResolutionInterfaceType newType) {
     return enclosingClass.thisType.substByContext(newType);
   }
 
   @override
-  DartType computeType(Resolution resolution) => type;
+  ResolutionDartType computeType(Resolution resolution) => type;
 
   @override
   bool get isConst => false;
 
   @override
   bool get isClassMember => true;
 
   @override
   bool get isDefaultConstructor => false;
 
@@ skipping 83 matching lines @@
   @override
   PrefixElement get redirectionDeferredPrefix => null;
 
   @override
   int get sourceOffset => enclosingClass.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 
   @override
-  FunctionType get type {
+  ResolutionFunctionType get type {
     // TODO(johnniwinther): Ensure that the function type substitutes type
     // variables correctly.
     return definingConstructor.type;
   }
 
   @override
-  List<DartType> get typeVariables => _unsupported("typeVariables");
+  List<ResolutionDartType> get typeVariables => _unsupported("typeVariables");
 }
 
 abstract class MemberElementMixin
     implements DeserializedElementZ, MemberElement {
   final List<FunctionElement> nestedClosures = <FunctionElement>[];
 
   @override
   MemberElement get memberContext => this;
 
   @override
@@ skipping 270 matching lines @@
   StaticSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 class InstanceSetterElementZ extends SetterElementZ
     with ClassMemberMixin, InstanceMemberMixin {
   InstanceSetterElementZ(ObjectDecoder decoder) : super(decoder);
 }
 
 abstract class TypeDeclarationMixin<T extends GenericType>
     implements ElementZ, TypeDeclarationElement {
-  List<DartType> _typeVariables;
+  List<ResolutionDartType> _typeVariables;
   T _rawType;
   T _thisType;
   Name _memberName;
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
 
-  List<DartType> _getTypeVariables();
+  List<ResolutionDartType> _getTypeVariables();
 
   void _ensureTypes() {
     if (_typeVariables == null) {
       _typeVariables = _getTypeVariables();
-      _rawType = _createType(new List<DartType>.filled(
-          _typeVariables.length, const DynamicType()));
+      _rawType = _createType(new List<ResolutionDartType>.filled(
+          _typeVariables.length, const ResolutionDynamicType()));
       _thisType = _createType(_typeVariables);
     }
   }
 
-  T _createType(List<DartType> typeArguments);
+  T _createType(List<ResolutionDartType> typeArguments);
 
   @override
-  List<DartType> get typeVariables {
+  List<ResolutionDartType> get typeVariables {
     _ensureTypes();
     return _typeVariables;
   }
 
   @override
   T get rawType {
     _ensureTypes();
     return _rawType;
   }
 
   @override
   T get thisType {
     _ensureTypes();
     return _thisType;
   }
 
   @override
   T computeType(Resolution resolution) => thisType;
 
   @override
   bool get isResolved => true;
 }
 
 class TypedefElementZ extends DeserializedElementZ
     with
         AnalyzableElementMixin,
         AstElementMixinZ,
         LibraryMemberMixin,
         ParametersMixin,
-        TypeDeclarationMixin<TypedefType>
+        TypeDeclarationMixin<ResolutionTypedefType>
     implements TypedefElement {
-  DartType _alias;
+  ResolutionDartType _alias;
 
   TypedefElementZ(ObjectDecoder decoder) : super(decoder);
 
-  TypedefType _createType(List<DartType> typeArguments) {
-    return new TypedefType(this, typeArguments);
+  ResolutionTypedefType _createType(List<ResolutionDartType> typeArguments) {
+    return new ResolutionTypedefType(this, typeArguments);
   }
 
   @override
-  List<DartType> _getTypeVariables() {
+  List<ResolutionDartType> _getTypeVariables() {
     return _decoder.getTypes(Key.TYPE_VARIABLES, isOptional: true);
   }
 
   @override
   ElementKind get kind => ElementKind.TYPEDEF;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypedefElement(this, arg);
   }
 
   @override
-  DartType get alias {
+  ResolutionDartType get alias {
     if (_alias == null) {
       _alias = _decoder.getType(Key.ALIAS);
     }
     return _alias;
   }
 
   @override
   void ensureResolved(Resolution resolution) {}
 
   @override
   void checkCyclicReference(Resolution resolution) {}
 }
 
 class TypeVariableElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, AstElementMixinZ, TypedElementMixin
     implements TypeVariableElement {
   GenericElement _typeDeclaration;
-  TypeVariableType _type;
-  DartType _bound;
+  ResolutionTypeVariableType _type;
+  ResolutionDartType _bound;
   Name _memberName;
 
   TypeVariableElementZ(ObjectDecoder decoder) : super(decoder);
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
@@ skipping 21 matching lines @@
   int get index => _decoder.getInt(Key.INDEX);
 
   @override
   GenericElement get typeDeclaration {
     if (_typeDeclaration == null) {
       _typeDeclaration = _decoder.getElement(Key.TYPE_DECLARATION);
     }
     return _typeDeclaration;
   }
 
-  DartType get bound {
+  ResolutionDartType get bound {
     if (_bound == null) {
       _bound = _decoder.getType(Key.BOUND);
     }
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 }
 
 class SyntheticTypeVariableElementZ extends ElementZ
     with AnalyzableElementMixin, AstElementMixinZ
     implements TypeVariableElement {
   final TypeDeclarationElement typeDeclaration;
   final int index;
   final String name;
-  TypeVariableType _type;
-  DartType _bound;
+  ResolutionTypeVariableType _type;
+  ResolutionDartType _bound;
   Name _memberName;
 
   SyntheticTypeVariableElementZ(this.typeDeclaration, this.index, this.name);
 
   Name get memberName {
     if (_memberName == null) {
       _memberName = new Name(name, library);
     }
     return _memberName;
   }
 
   @override
   ElementKind get kind => ElementKind.TYPE_VARIABLE;
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitTypeVariableElement(this, arg);
   }
 
   @override
   CompilationUnitElement get compilationUnit {
     return typeDeclaration.compilationUnit;
   }
 
   @override
-  TypeVariableType get type {
+  ResolutionTypeVariableType get type {
     assert(invariant(this, _type != null,
         message: "Type variable type has not been set on $this."));
     return _type;
   }
 
   @override
-  TypeVariableType computeType(Resolution resolution) => type;
+  ResolutionTypeVariableType computeType(Resolution resolution) => type;
 
   @override
   Element get enclosingElement => typeDeclaration;
 
   @override
   Element get enclosingClass => typeDeclaration;
 
-  DartType get bound {
+  ResolutionDartType get bound {
     assert(invariant(this, _bound != null,
         message: "Type variable bound has not been set on $this."));
     return _bound;
   }
 
   @override
   LibraryElement get library => typeDeclaration.library;
 
   @override
   int get sourceOffset => typeDeclaration.sourceOffset;
 
   @override
   SourceSpan get sourcePosition => typeDeclaration.sourcePosition;
 }
 
 abstract class ParameterElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, AstElementMixinZ, TypedElementMixin
     implements ParameterElement {
   FunctionElement _functionDeclaration;
   ConstantExpression _constant;
-  DartType _type;
+  ResolutionDartType _type;
 
   ParameterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   bool get isFinal => _decoder.getBool(Key.IS_FINAL);
 
   @override
   bool get isConst => false;
 
   @override
@@ skipping 46 matching lines @@
   @override
   bool get isOptional => _decoder.getBool(Key.IS_OPTIONAL);
 
   @override
   LibraryElement get library => executableContext.library;
 
   @override
   MemberElement get memberContext => executableContext.memberContext;
 
   @override
-  List<DartType> get typeVariables => functionSignature.typeVariables;
+  List<ResolutionDartType> get typeVariables => functionSignature.typeVariables;
 }
 
 class LocalParameterElementZ extends ParameterElementZ
     implements LocalParameterElement {
   LocalParameterElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   accept(ElementVisitor visitor, arg) {
     return visitor.visitParameterElement(this, arg);
   }
@@ skipping 257 matching lines @@
   }
 
   @override
   Node get node => throw new UnsupportedError('${this}.node');
 
   @override
   bool get hasNode => false;
 
   String toString() => 'MetadataAnnotationZ(${constant.toDartText()})';
 }