Move TypeParameterizedElementForLink and TypeParameterElementForLink to impl.

pkg/analyzer/lib/src/summary/link.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 file.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 142 matching lines @@
 
 /**
  * Create an [EntityRefBuilder] representing the given [type], in a form
  * suitable for inclusion in [LinkedUnit.types].  [compilationUnit] is the
  * compilation unit in which the type will be used.  If [slot] is provided, it
  * is stored in [EntityRefBuilder.slot].
  */
 EntityRefBuilder _createLinkedType(
     DartType type,
     CompilationUnitElementInBuildUnit compilationUnit,
-    TypeParameterizedElementForLink typeParameterContext,
+    TypeParameterizedElementMixin typeParameterContext,
     {int slot}) {
   EntityRefBuilder result = new EntityRefBuilder(slot: slot);
   if (type is InterfaceType) {
     ClassElementForLink element = type.element;
     result.reference = compilationUnit.addReference(element);
     _storeTypeArguments(
         type.typeArguments, result, compilationUnit, typeParameterContext);
     return result;
   } else if (type is DynamicTypeImpl) {
     result.reference = compilationUnit.addRawReference('dynamic');
     return result;
   } else if (type is VoidTypeImpl) {
     result.reference = compilationUnit.addRawReference('void');
     return result;
   } else if (type is BottomTypeImpl) {
     result.reference = compilationUnit.addRawReference('*bottom*');
     return result;
   } else if (type is TypeParameterType) {
-    TypeParameterElementForLink element = type.element;
+    TypeParameterElementImpl element = type.element;
     if (typeParameterContext.isTypeParameterInScope(element)) {
       result.paramReference =
           typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
     } else {
       // Out-of-scope type parameters only occur in circumstances where they
       // are irrelevant (i.e. when a type parameter is unused).  So we can
       // safely convert them to `dynamic`.
       result.reference = compilationUnit.addRawReference('dynamic');
     }
     return result;
@@ skipping 51 matching lines @@
 
 /**
  * Create an [UnlinkedParam] representing the given [parameter], which should be
  * a parameter of a synthetic function type (e.g. one produced during type
  * inference as a result of computing the least upper bound of two function
  * types).
  */
 UnlinkedParamBuilder _serializeSyntheticParam(
     ParameterElement parameter,
     CompilationUnitElementInBuildUnit compilationUnit,
-    TypeParameterizedElementForLink typeParameterContext) {
+    TypeParameterizedElementMixin typeParameterContext) {
   UnlinkedParamBuilder b = new UnlinkedParamBuilder();
   b.name = parameter.name;
   switch (parameter.parameterKind) {
     case ParameterKind.REQUIRED:
       b.kind = UnlinkedParamKind.required;
       break;
     case ParameterKind.POSITIONAL:
       b.kind = UnlinkedParamKind.positional;
       break;
     case ParameterKind.NAMED:
@@ skipping 18 matching lines @@
 }
 
 /**
  * Store the given [typeArguments] in [encodedType], using [compilationUnit] and
  * [typeParameterContext] to serialize them.
  */
 void _storeTypeArguments(
     List<DartType> typeArguments,
     EntityRefBuilder encodedType,
     CompilationUnitElementInBuildUnit compilationUnit,
-    TypeParameterizedElementForLink typeParameterContext) {
+    TypeParameterizedElementMixin typeParameterContext) {
   int count = typeArguments.length;
   List<EntityRefBuilder> encodedTypeArguments =
       new List<EntityRefBuilder>(count);
   for (int i = 0; i < count; i++) {
     encodedTypeArguments[i] = _createLinkedType(
         typeArguments[i], compilationUnit, typeParameterContext);
   }
   encodedType.typeArguments = encodedTypeArguments;
 }
 
@@ skipping 52 matching lines @@
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   List<MethodElementForLink> get methods;
 
   @override
   String get name;
 
   @override
+  ResynthesizerContext get resynthesizerContext => enclosingElement;
+
+  @override
   ConstructorElementForLink get unnamedConstructor;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     if (_containedNames == null) {
       _containedNames = <String, ReferenceableElementForLink>{};
       // TODO(paulberry): what's the correct way to handle name conflicts?
       for (ConstructorElementForLink constructor in constructors) {
         _containedNames[constructor.name] = constructor;
       }
@@ skipping 20 matching lines @@
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a class resynthesized from a summary during
  * linking.
  */
 class ClassElementForLink_Class extends ClassElementForLink
-    with TypeParameterizedElementForLink {
+    with TypeParameterizedElementMixin {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
   List<FieldElementForLink_ClassField> _fields;
   InterfaceType _supertype;
@@ skipping 65 matching lines @@
         _constructors.add(_unnamedConstructor);
       }
     }
     return _constructors;
   }
 
   @override
   String get displayName => _unlinkedClass.name;
 
   @override
-  TypeParameterizedElementForLink get enclosingTypeParameterContext => null;
+  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   List<FieldElementForLink_ClassField> get fields {
     if (_fields == null) {
       _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
         _fields.add(new FieldElementForLink_ClassField(this, field));
       }
     }
     return _fields;
@@ skipping 43 matching lines @@
       return null;
     }
     return _supertype ??= _computeInterfaceType(_unlinkedClass.supertype);
   }
 
   @override
   DartType get type =>
       _type ??= buildType((int i) => typeParameterTypes[i], null);
 
   @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams =>
+      _unlinkedClass.typeParameters;
+
+  @override
   ConstructorElementForLink get unnamedConstructor {
     if (!_unnamedConstructorComputed) {
       for (ConstructorElementForLink constructor in constructors) {
         if (constructor.name.isEmpty) {
           _unnamedConstructor = constructor;
           break;
         }
       }
       _unnamedConstructorComputed = true;
     }
     return _unnamedConstructor;
   }
 
   @override
-  List<UnlinkedTypeParam> get _unlinkedTypeParams =>
-      _unlinkedClass.typeParameters;
-
-  @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedClass.typeParameters.length;
     if (numTypeParameters != 0) {
       return new InterfaceTypeImpl.elementWithNameAndArgs(this, name, () {
         List<DartType> typeArguments = new List<DartType>(numTypeParameters);
         for (int i = 0; i < numTypeParameters; i++) {
           typeArguments[i] = getTypeArgument(i);
         }
         return typeArguments;
@@ skipping 43 matching lines @@
   }
 
   @override
   String toString() => '$enclosingElement.$name';
 
   /**
    * Convert [typeRef] into an [InterfaceType].
    */
   InterfaceType _computeInterfaceType(EntityRef typeRef) {
     if (typeRef != null) {
-      DartType type = enclosingElement._resolveTypeRef(typeRef, this);
+      DartType type = enclosingElement.resolveTypeRef(typeRef, this);
       if (type is InterfaceType) {
         return type;
       }
       // In the event that the `typeRef` isn't an interface type (which may
       // happen in the event of erroneous code) just fall through and pretend
       // the supertype is `Object`.
     }
     return enclosingElement.enclosingElement._linker.typeProvider.objectType;
   }
 }
@@ skipping 89 matching lines @@
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Element representing a compilation unit resynthesized from a
  * summary during linking.
  */
 abstract class CompilationUnitElementForLink
-    implements CompilationUnitElementImpl {
+    implements CompilationUnitElementImpl, ResynthesizerContext {
   /**
    * The unlinked representation of the compilation unit in the
    * summary.
    */
   final UnlinkedUnit _unlinkedUnit;
 
   /**
    * For each entry in [UnlinkedUnit.references], the element referred
    * to by the reference, or `null` if it hasn't been located yet.
    */
@@ skipping 176 matching lines @@
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Compute the type referred to by the given linked type [slot] (interpreted
    * relative to [typeParameterContext]).  If there is no inferred type in the
    * given slot, `dynamic` is returned.
    */
   DartType getLinkedType(
-      int slot, TypeParameterizedElementForLink typeParameterContext);
+      int slot, TypeParameterizedElementMixin typeParameterContext);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
+  /**
+   * Resolve an [EntityRef] into a type.  If the reference is
+   * unresolved, return [DynamicTypeImpl.instance].
+   *
+   * TODO(paulberry): or should we have a class representing an
+   * unresolved type, for consistency with the full element model?
+   */

[Paul Berry, 2016/05/17 19:28:02]

Nit: remove this comment and add an "@override" annotation, since this is now
overriding an abstract method in ResynthesizerContext.

[scheglov, 2016/05/17 19:42:21]

Done.

+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
+      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
+    if (type == null) {
+      if (defaultVoid) {
+        return VoidTypeImpl.instance;
+      } else {
+        return DynamicTypeImpl.instance;
+      }
+    }
+    if (type.paramReference != 0) {
+      return typeParameterContext.getTypeParameterType(type.paramReference);
+    } else if (type.syntheticReturnType != null) {
+      // TODO(paulberry): implement.
+      throw new UnimplementedError();
+    } else if (type.implicitFunctionTypeIndices.isNotEmpty) {
+      // TODO(paulberry): implement.
+      throw new UnimplementedError();
+    } else {
+      DartType getTypeArgument(int i) {
+        if (i < type.typeArguments.length) {
+          return resolveTypeRef(type.typeArguments[i], typeParameterContext);
+        } else {
+          return DynamicTypeImpl.instance;
+        }
+      }
+      ReferenceableElementForLink element = _resolveRef(type.reference);
+      return element.buildType(
+          getTypeArgument, type.implicitFunctionTypeIndices);
+    }
+  }
+
   @override
   String toString() => enclosingElement.toString();
 
   /**
    * Return the element referred to by the given [index] in
    * [UnlinkedUnit.references].  If the reference is unresolved,
    * return [UndefinedElementForLink.instance].
    */
   ReferenceableElementForLink _resolveRef(int index) {
     if (_references[index] == null) {
@@ skipping 24 matching lines @@
           _references[index] = enclosingElement.getContainedName(name);
         }
       } else {
         LibraryElementForLink dependency =
             enclosingElement._getDependency(linkedReference.dependency);
         _references[index] = dependency.getContainedName(name);
       }
     }
     return _references[index];
   }
-
-  /**
-   * Resolve an [EntityRef] into a type.  If the reference is
-   * unresolved, return [DynamicTypeImpl.instance].
-   *
-   * TODO(paulberry): or should we have a class representing an
-   * unresolved type, for consistency with the full element model?
-   */
-  DartType _resolveTypeRef(
-      EntityRef type, TypeParameterizedElementForLink typeParameterContext,
-      {bool defaultVoid: false}) {
-    if (type == null) {
-      if (defaultVoid) {
-        return VoidTypeImpl.instance;
-      } else {
-        return DynamicTypeImpl.instance;
-      }
-    }
-    if (type.paramReference != 0) {
-      return typeParameterContext.getTypeParameterType(type.paramReference);
-    } else if (type.syntheticReturnType != null) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
-    } else if (type.implicitFunctionTypeIndices.isNotEmpty) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
-    } else {
-      DartType getTypeArgument(int i) {
-        if (i < type.typeArguments.length) {
-          return _resolveTypeRef(type.typeArguments[i], typeParameterContext);
-        } else {
-          return DynamicTypeImpl.instance;
-        }
-      }
-      ReferenceableElementForLink element = _resolveRef(type.reference);
-      return element.buildType(
-          getTypeArgument, type.implicitFunctionTypeIndices);
-    }
-  }
 }
 
 /**
  * Element representing a compilation unit which is part of the build
  * unit being linked.
  */
 class CompilationUnitElementInBuildUnit extends CompilationUnitElementForLink {
   @override
   final LinkedUnitBuilder _linkedUnit;
 
@@ skipping 131 matching lines @@
       return addRawReference(element.name,
           containingReference: addReference(enclosingClass),
           kind: ReferenceKind.propertyAccessor);
     }
     // TODO(paulberry): implement other cases
     throw new UnimplementedError('${element.runtimeType}');
   }
 
   @override
   DartType getLinkedType(
-      int slot, TypeParameterizedElementForLink typeParameterContext) {
+      int slot, TypeParameterizedElementMixin typeParameterContext) {
     // This method should only be called on compilation units that come from
     // dependencies, never on compilation units that are part of the current
     // build unit.
     throw new StateError(
         'Linker tried to access linked type from current build unit');
   }
 
   /**
    * Perform type inference and const cycle detection on this
    * compilation unit.
@@ skipping 28 matching lines @@
    */
   void _storeConstCycle(int slot) {
     _linkedUnit.constCycles.add(slot);
   }
 
   /**
    * Store the given [linkedType] in the given [slot] of the this compilation
    * unit's linked type list.
    */
   void _storeLinkedType(int slot, DartType linkedType,
-      TypeParameterizedElementForLink typeParameterContext) {
+      TypeParameterizedElementMixin typeParameterContext) {
     if (slot != 0) {
       if (linkedType != null && !linkedType.isDynamic) {
         _linkedUnit.types.add(_createLinkedType(
             linkedType, this, typeParameterContext,
             slot: slot));
       }
     }
   }
 }
 
@@ skipping 36 matching lines @@
     for (EntityRef ref in _linkedUnit.types) {
       _linkedTypeRefs[ref.slot] = ref;
     }
   }
 
   @override
   bool get isInBuildUnit => false;
 
   @override
   DartType getLinkedType(
-      int slot, TypeParameterizedElementForLink typeParameterContext) {
+      int slot, TypeParameterizedElementMixin typeParameterContext) {
     if (slot < _linkedTypeRefs.length) {
-      return _resolveTypeRef(_linkedTypeRefs[slot], typeParameterContext);
+      return resolveTypeRef(_linkedTypeRefs[slot], typeParameterContext);
     } else {
       return DynamicTypeImpl.instance;
     }
   }
 }
 
 /**
  * Instance of [ConstNode] representing a constant constructor.
  */
 class ConstConstructorNode extends ConstNode {
@@ skipping 439 matching lines @@
     // Kick off the algorithm starting with the starting point.
     strongConnect(startingPoint);
   }
 }
 
 /**
  * Base class for executable elements resynthesized from a summary during
  * linking.
  */
 abstract class ExecutableElementForLink extends Object
-    with TypeParameterizedElementForLink, ParameterParentElementForLink
+    with TypeParameterizedElementMixin, ParameterParentElementForLink
     implements ExecutableElementImpl {
   /**
    * The unlinked representation of the method in the summary.
    */
   final UnlinkedExecutable _unlinkedExecutable;
 
   DartType _declaredReturnType;
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   String _name;
@@ skipping 13 matching lines @@
 
   /**
    * If the executable element had an explicitly declared return type, return
    * it.  Otherwise return `null`.
    */
   DartType get declaredReturnType {
     if (_unlinkedExecutable.returnType == null) {
       return null;
     } else {
       return _declaredReturnType ??=
-          compilationUnit._resolveTypeRef(_unlinkedExecutable.returnType, this);
+          compilationUnit.resolveTypeRef(_unlinkedExecutable.returnType, this);
     }
   }
 
   @override
   String get displayName {
     if (_displayName == null) {
       _displayName = _unlinkedExecutable.name;
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
         _displayName = _displayName.substring(0, _displayName.length - 1);
       }
     }
     return _displayName;
   }
 
   @override
   Element get enclosingElement => enclosingClass ?? compilationUnit;
 
   @override
-  TypeParameterizedElementForLink get enclosingTypeParameterContext =>
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
       enclosingClass;
 
   @override
   bool get hasImplicitReturnType => _unlinkedExecutable.returnType == null;
 
   @override
   List<int> get implicitFunctionTypeIndices => const <int>[];
 
   /**
    * Return the inferred return type of the executable element.  Should only be
@@ skipping 38 matching lines @@
     if (_name == null) {
       _name = _unlinkedExecutable.name;
       if (_name == '-' && _unlinkedExecutable.parameters.isEmpty) {
         _name = 'unary-';
       }
     }
     return _name;
   }
 
   @override
+  ResynthesizerContext get resynthesizerContext => compilationUnit;
+
+  @override
   DartType get returnType => declaredReturnType ?? inferredReturnType;
 
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
 
   @override
   FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
 
   @override
-  TypeParameterizedElementForLink get typeParameterContext => this;
+  TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<UnlinkedParam> get unlinkedParameters => _unlinkedExecutable.parameters;
 
   @override
-  List<UnlinkedTypeParam> get _unlinkedTypeParams =>
+  List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedExecutable.typeParameters;
 
   @override
   bool isAccessibleIn(LibraryElement library) =>
       !Identifier.isPrivateName(name) || identical(this.library, library);
 
   /**
    * Store the results of type inference for this method in [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
@@ skipping 356 matching lines @@
     stack.length -= numNamed + numPositional;
     strPtr += numNamed;
     EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
         unit._resolveRef(ref.reference).asConstructor;
     if (element != null) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       stack.add(enclosingClass.buildType((int i) {
         // Type argument explicitly specified.
         if (i < ref.typeArguments.length) {
-          return unit._resolveTypeRef(
+          return unit.resolveTypeRef(
               ref.typeArguments[i], variable._typeParameterContext);
         }
         // In strong mode, type argument defaults to bound (if any).
         if (linker.strongMode) {
           TypeParameterElement typeParameter = enclosingClass.typeParameters[i];
           if (typeParameter.bound != null) {
             return typeParameter.bound;
           }
         }
         // Otherwise type argument defaults to `dynamic`.
@@ skipping 119 matching lines @@
   List<String> _getNextStrings(int n) {
     List<String> result = new List<String>(n);
     for (int i = 0; i < n; i++) {
       result[i] = _getNextString();
     }
     return result;
   }
 
   DartType _getNextTypeRef() {
     EntityRef ref = _getNextRef();
-    return unit._resolveTypeRef(ref, variable._typeParameterContext);
+    return unit.resolveTypeRef(ref, variable._typeParameterContext);
   }
 
   /**
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
         ? targetType.lookUpGetter(propertyName, library)?.returnType
@@ skipping 166 matching lines @@
   bool get isStatic => unlinkedVariable.isStatic;
 
   @override
   void set type(DartType inferredType) {
     assert(!isStatic);
     assert(_inferredInstanceType == null);
     _inferredInstanceType = inferredType;
   }
 
   @override
-  TypeParameterizedElementForLink get _typeParameterContext => enclosingElement;
+  TypeParameterizedElementMixin get _typeParameterContext => enclosingElement;
 
   /**
    * Store the results of type inference for this field in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       compilationUnit._storeLinkedType(
           unlinkedVariable.inferredTypeSlot,
           isStatic ? inferredType : _inferredInstanceType,
@@ skipping 53 matching lines @@
  * Element representing a function-typed parameter resynthesied from a summary
  * during linking.
  */
 class FunctionElementForLink_FunctionTypedParam extends Object
     with ParameterParentElementForLink
     implements FunctionElement {
   @override
   final ParameterElementForLink enclosingElement;
 
   @override
-  final TypeParameterizedElementForLink typeParameterContext;
+  final TypeParameterizedElementMixin typeParameterContext;
 
   @override
   final List<UnlinkedParam> unlinkedParameters;
 
   DartType _returnType;
   List<int> _implicitFunctionTypeIndices;
 
   FunctionElementForLink_FunctionTypedParam(this.enclosingElement,
       this.typeParameterContext, this.unlinkedParameters);
 
   @override
   List<int> get implicitFunctionTypeIndices {
     if (_implicitFunctionTypeIndices == null) {
       _implicitFunctionTypeIndices = enclosingElement
           .enclosingElement.implicitFunctionTypeIndices
           .toList();
       _implicitFunctionTypeIndices.add(enclosingElement._parameterIndex);
     }
     return _implicitFunctionTypeIndices;
   }
 
   @override
   DartType get returnType {
     if (_returnType == null) {
       if (enclosingElement._unlinkedParam.type == null) {
         _returnType = DynamicTypeImpl.instance;
       } else {
-        _returnType = enclosingElement.compilationUnit._resolveTypeRef(
+        _returnType = enclosingElement.compilationUnit.resolveTypeRef(
             enclosingElement._unlinkedParam.type, typeParameterContext);
       }
     }
     return _returnType;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
@@ skipping 73 matching lines @@
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a typedef resynthesized from a summary during linking.
  */
 class FunctionTypeAliasElementForLink extends Object
     with
-        TypeParameterizedElementForLink,
+        TypeParameterizedElementMixin,
         ParameterParentElementForLink,
         ReferenceableElementForLink
     implements FunctionTypeAliasElement, ElementImpl {
   @override
   final CompilationUnitElementForLink enclosingElement;
 
   /**
    * The unlinked representation of the typedef in the summary.
    */
   final UnlinkedTypedef _unlinkedTypedef;
 
   FunctionTypeImpl _type;
   DartType _returnType;
 
   FunctionTypeAliasElementForLink(this.enclosingElement, this._unlinkedTypedef);
 
   @override
   DartType get asStaticType {
     return enclosingElement.enclosingElement._linker.typeProvider.typeType;
   }
 
   @override
   CompilationUnitElementForLink get compilationUnit => enclosingElement;
 
   @override
-  TypeParameterizedElementForLink get enclosingTypeParameterContext => null;
+  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   String get identifier => _unlinkedTypedef.name;
 
   @override
   List<int> get implicitFunctionTypeIndices => const <int>[];
 
   @override
   bool get isSynthetic => false;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name => _unlinkedTypedef.name;
 
   @override
-  DartType get returnType => _returnType ??=
-      enclosingElement._resolveTypeRef(_unlinkedTypedef.returnType, this);
+  ResynthesizerContext get resynthesizerContext => enclosingElement;
 
   @override
-  TypeParameterizedElementForLink get typeParameterContext => this;
+  DartType get returnType => _returnType ??=
+      enclosingElement.resolveTypeRef(_unlinkedTypedef.returnType, this);
+
+  @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<UnlinkedParam> get unlinkedParameters => _unlinkedTypedef.parameters;
 
   @override
-  List<UnlinkedTypeParam> get _unlinkedTypeParams =>
+  List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef.typeParameters;
 
   @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedTypedef.typeParameters.length;
     if (numTypeParameters != 0) {
       List<DartType> typeArguments = new List<DartType>(numTypeParameters);
       for (int i = 0; i < numTypeParameters; i++) {
         typeArguments[i] = getTypeArgument(i);
@@ skipping 687 matching lines @@
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
   final UnlinkedParam _unlinkedParam;
 
   /**
    * The innermost enclosing element that can declare type parameters.
    */
-  final TypeParameterizedElementForLink _typeParameterContext;
+  final TypeParameterizedElementMixin _typeParameterContext;
 
   /**
    * If this parameter has a default value and the enclosing library
    * is part of the build unit being linked, the parameter's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstNode _constNode;
 
   /**
    * The compilation unit in which this parameter appears.
@@ skipping 51 matching lines @@
                 this, _typeParameterContext, _unlinkedParam.parameters));
       } else if (_unlinkedParam.type == null) {
         if (!compilationUnit.isInBuildUnit) {
           _inferredType = compilationUnit.getLinkedType(
               _unlinkedParam.inferredTypeSlot, _typeParameterContext);
           return _inferredType;
         } else {
           _declaredType = DynamicTypeImpl.instance;
         }
       } else {
-        _declaredType = compilationUnit._resolveTypeRef(
+        _declaredType = compilationUnit.resolveTypeRef(
             _unlinkedParam.type, _typeParameterContext);
       }
     }
     return _declaredType;
   }
 
   @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
@@ skipping 56 matching lines @@
   /**
    * Get all the parameters of this element.
    */
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
       List<UnlinkedParam> unlinkedParameters = this.unlinkedParameters;
       int numParameters = unlinkedParameters.length;
       _parameters = new List<ParameterElementForLink>(numParameters);
       for (int i = 0; i < numParameters; i++) {
         UnlinkedParam unlinkedParam = unlinkedParameters[i];
-        _parameters[i] = new ParameterElementForLink(this, unlinkedParam,
-            typeParameterContext, typeParameterContext.compilationUnit, i);
+        _parameters[i] = new ParameterElementForLink(
+            this,
+            unlinkedParam,
+            typeParameterContext,
+            typeParameterContext.resynthesizerContext
+            as CompilationUnitElementForLink,
+            i);
       }
     }
     return _parameters;
   }
 
   /**
    * Get the innermost enclosing element that can declare type parameters (which
    * may be [this], or may be a parent when there are function-typed
    * parameters).
    */
-  TypeParameterizedElementForLink get typeParameterContext;
+  TypeParameterizedElementMixin get typeParameterContext;
 
   /**
    * Get the list of unlinked parameters of this element.
    */
   List<UnlinkedParam> get unlinkedParameters;
 }
 
 /**
  * Element representing a getter or setter resynthesized from a summary during
  * linking.
@@ skipping 345 matching lines @@
   DartType _returnType;
 
   TopLevelFunctionElementForLink(
       CompilationUnitElementForLink enclosingUnit, UnlinkedExecutable _buf)
       : super(enclosingUnit, null, _buf);
 
   @override
   DartType get asStaticType => type;
 
   @override
+  String get identifier => _unlinkedExecutable.name;
+
+  @override
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class TopLevelVariableElementForLink extends VariableElementForLink
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElementForLink enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
   CompilationUnitElementForLink get enclosingElement => compilationUnit;
 
   @override
   bool get isStatic => true;
 
   @override
   LibraryElementForLink get library => compilationUnit.library;
 
   @override
-  TypeParameterizedElementForLink get _typeParameterContext => null;
+  TypeParameterizedElementMixin get _typeParameterContext => null;
 
   /**
    * Store the results of type inference for this variable in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (hasImplicitType) {
       TypeInferenceNode typeInferenceNode = this._typeInferenceNode;
       if (typeInferenceNode != null) {
         compilationUnit._storeLinkedType(
@@ skipping 108 matching lines @@
     } else {
       variableElement._inferredType =
           new ExprTypeComputer(variableElement).compute();
     }
   }
 
   @override
   String toString() => 'TypeInferenceNode($variableElement)';
 }
 
-/**
- * Element representing a type parameter resynthesized from a summary during
- * linking.
- */
-class TypeParameterElementForLink implements TypeParameterElementImpl {
-  /**
-   * The unlinked representation of the type parameter in the summary.
-   */
-  final UnlinkedTypeParam _unlinkedTypeParam;
-
-  /**
-   * The number of type parameters whose scope overlaps this one, and which are
-   * declared earlier in the file.
-   */
-  final int nestingLevel;
-
-  @override
-  final TypeParameterizedElementForLink enclosingElement;
-
-  TypeParameterTypeImpl _type;
-  ElementLocation _location;
-
-  DartType _bound;
-
-  TypeParameterElementForLink(
-      this.enclosingElement, this._unlinkedTypeParam, this.nestingLevel);
-
-  @override
-  DartType get bound {
-    if (_unlinkedTypeParam.bound == null) {
-      return null;
-    }
-    return _bound ??= enclosingElement.compilationUnit
-        ._resolveTypeRef(_unlinkedTypeParam.bound, enclosingElement);
-  }
-
-  @override
-  String get identifier => name;
-
-  @override
-  ElementKind get kind => ElementKind.TYPE_PARAMETER;
-
-  @override
-  ElementLocation get location =>
-      _location ??= new ElementLocationImpl.con1(this);
-
-  @override
-  String get name => _unlinkedTypeParam.name;
-
-  @override
-  TypeParameterTypeImpl get type => _type ??= new TypeParameterTypeImpl(this);
-
-  @override
-  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
-
-/**
- * Mixin representing an element which can have type parameters.
- */
-abstract class TypeParameterizedElementForLink
-    implements TypeParameterizedElement {
-  List<TypeParameterType> _typeParameterTypes;
-  List<TypeParameterElementForLink> _typeParameters;
-  int _nestingLevel;
-
-  /**
-   * Get the compilation unit in which this element is declared.
-   */
-  CompilationUnitElementForLink get compilationUnit;
-
-  /**
-   * Get the type parameter context enclosing this one, if any.
-   */
-  TypeParameterizedElementForLink get enclosingTypeParameterContext;
-
-  /**
-   * Find out how many type parameters are in scope in this context.
-   */
-  int get typeParameterNestingLevel =>
-      _nestingLevel ??= _unlinkedTypeParams.length +
-          (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
-
-  List<TypeParameterElementForLink> get typeParameters {
-    if (_typeParameters == null) {
-      int enclosingNestingLevel =
-          enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
-      int numTypeParameters = _unlinkedTypeParams.length;
-      _typeParameters =
-          new List<TypeParameterElementForLink>(numTypeParameters);
-      for (int i = 0; i < numTypeParameters; i++) {
-        _typeParameters[i] = new TypeParameterElementForLink(
-            this, _unlinkedTypeParams[i], enclosingNestingLevel + i);
-      }
-    }
-    return _typeParameters;
-  }
-
-  /**
-   * Get a list of [TypeParameterType] objects corresponding to the
-   * element's type parameters.
-   */
-  List<TypeParameterType> get typeParameterTypes {
-    if (_typeParameterTypes == null) {
-      _typeParameterTypes = typeParameters
-          .map((TypeParameterElementForLink e) => e.type)
-          .toList();
-    }
-    return _typeParameterTypes;
-  }
-
-  /**
-   * Get the [UnlinkedTypeParam]s representing the type parameters declared by
-   * this element.
-   */
-  List<UnlinkedTypeParam> get _unlinkedTypeParams;
-
-  /**
-   * Convert the given [index] into a type parameter type.
-   */
-  TypeParameterType getTypeParameterType(int index) {
-    List<TypeParameterType> types = typeParameterTypes;
-    if (index <= types.length) {
-      return types[types.length - index];
-    } else if (enclosingTypeParameterContext != null) {
-      return enclosingTypeParameterContext
-          .getTypeParameterType(index - types.length);
-    } else {
-      // If we get here, it means that a summary contained a type parameter index
-      // that was out of range.
-      throw new RangeError('Invalid type parameter index');
-    }
-  }
-
-  /**
-   * Find out if the given [typeParameter] is in scope in this context.
-   */
-  bool isTypeParameterInScope(TypeParameterElementForLink typeParameter) {
-    if (typeParameter.enclosingElement == this) {
-      return true;
-    } else if (enclosingTypeParameterContext != null) {
-      return enclosingTypeParameterContext
-          .isTypeParameterInScope(typeParameter);
-    } else {
-      return false;
-    }
-  }
-}
-
 class TypeProviderForLink implements TypeProvider {
   final Linker _linker;
 
   InterfaceType _boolType;
   InterfaceType _deprecatedType;
   InterfaceType _doubleType;
   InterfaceType _functionType;
   InterfaceType _futureDynamicType;
   InterfaceType _futureNullType;
   InterfaceType _futureType;
@@ skipping 189 matching lines @@
   }
 
   /**
    * If the variable has an explicitly declared return type, return it.
    * Otherwise return `null`.
    */
   DartType get declaredType {
     if (unlinkedVariable.type == null) {
       return null;
     } else {
-      return _declaredType ??= compilationUnit._resolveTypeRef(
+      return _declaredType ??= compilationUnit.resolveTypeRef(
           unlinkedVariable.type, _typeParameterContext);
     }
   }
 
   @override
   PropertyAccessorElementForLink_Variable get getter =>
       _getter ??= new PropertyAccessorElementForLink_Variable(this, false);
 
   @override
   bool get hasImplicitType => unlinkedVariable.type == null;
@@ skipping 71 matching lines @@
 
   @override
   void set type(DartType newType) {
     // TODO(paulberry): store inferred type.
   }
 
   /**
    * The context in which type parameters should be interpreted, or `null` if
    * there are no type parameters in scope.
    */
-  TypeParameterizedElementForLink get _typeParameterContext;
+  TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }