Add support for type inference involving generics.

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 110 matching lines @@
   new _Linker(libraries, getDependency, getUnit, strong).link();
 }
 
 /**
  * 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,
+    DartType type,
+    CompilationUnitElementInBuildUnit compilationUnit,
+    TypeParameterContext typeParameterContext,
     {int slot}) {
   EntityRefBuilder result = new EntityRefBuilder(slot: slot);
   if (type is InterfaceType) {
     ClassElementForLink element = type.element;
-    int dependency = compilationUnit.library.addDependency(element.library);
-    result.reference = compilationUnit.addReference(dependency, element.name,
-        element.typeParameters.length, element.enclosingElement.unitNum);
-    if (element.typeParameters.isNotEmpty) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
+    result.reference = compilationUnit.addReference(element);
+    if (type.typeArguments.isNotEmpty) {
+      result.typeArguments = type.typeArguments
+          .map((DartType t) =>
+              _createLinkedType(t, compilationUnit, typeParameterContext))
+          .toList();
     }
     return result;
   } else if (type is VoidTypeImpl) {
-    result.reference = compilationUnit.addReference(0, 'void', 0, 0);
+    result.reference = compilationUnit.addRawReference('void');
     return result;
+  } else if (type is TypeParameterType) {
+    TypeParameterElementForLink element = type.element;
+    result.paramReference =
+        typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
+    return result;
+  } else if (type is FunctionType) {
+    Element element = type.element;
+    if (element is FunctionElementForLink_FunctionTypedParam) {
+      result.reference =
+          compilationUnit.addReference(element.enclosingExecutable);
+      result.implicitFunctionTypeIndices = element.implicitFunctionTypeIndices;
+      if (type.typeArguments.isNotEmpty) {
+        result.typeArguments = type.typeArguments
+            .map((DartType t) =>
+                _createLinkedType(t, compilationUnit, typeParameterContext))
+            .toList();
+      }
+      return result;
+    }
+    // TODO(paulberry): implement other cases.
+    throw new UnimplementedError('${element.runtimeType}');
   }
+  // TODO(paulberry): implement other cases.
   throw new UnimplementedError('${type.runtimeType}');
 }
 
 /**
  * Type of the callback used by [link] and [relink] to request
  * [LinkedLibrary] objects from other build units.
  */
 typedef LinkedLibrary GetDependencyCallback(String absoluteUri);
 
 /**
@@ skipping 211 matching lines @@
 
   @override
   InterfaceType get supertype {
     if (isObject) {
       return null;
     }
     return _supertype ??= _computeInterfaceType(_unlinkedClass.supertype);
   }
 
   @override
+  DartType get type =>
+      _type ??= buildType((int i) => typeParameterTypes[i], null);
+
+  @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(this);
+      List<DartType> typeArguments = new List<DartType>(numTypeParameters);
+      for (int i = 0; i < numTypeParameters; i++) {
+        typeArguments[i] = getTypeArgument(i);
+      }
+      return new InterfaceTypeImpl.elementWithNameAndArgs(
+          this, name, typeArguments);
     } else {
-      if (_type == null) {
-        List<DartType> typeArguments = new List<DartType>(numTypeParameters);
-        for (int i = 0; i < numTypeParameters; i++) {
-          typeArguments[i] = getTypeArgument(i);
-        }
-        _type = new InterfaceTypeImpl.elementWithNameAndArgs(
-            this, name, typeArguments);
-      }
-      return _type;
+      return _type ??= new InterfaceTypeImpl(this);
     }
   }
 
   @override
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
       constructorElement.link(compilationUnit);
     }
     for (MethodElementForLink methodElement in methods) {
       methodElement.link(compilationUnit);
     }
     for (PropertyAccessorElementForLink propertyAccessorElement in accessors) {
       propertyAccessorElement.link(compilationUnit);
     }
     for (FieldElementForLink_ClassField fieldElement in fields) {
       fieldElement.link(compilationUnit);
     }
   }
 
   @override
   void unlink() {
     hasBeenInferred = false;
+    for (ConstructorElementForLink constructorElement in constructors) {
+      constructorElement.unlink();
+    }
     for (MethodElementForLink methodElement in methods) {
       methodElement.unlink();
     }
     for (PropertyAccessorElementForLink propertyAccessorElement in accessors) {
       propertyAccessorElement.unlink();
     }
     for (FieldElementForLink_ClassField fieldElement in fields) {
       fieldElement.unlink();
     }
   }
@@ skipping 281 matching lines @@
       : super(unlinkedUnit, unitNum);
 
   @override
   bool get isInBuildUnit => true;
 
   @override
   LibraryElementInBuildUnit get library => enclosingElement;
 
   /**
    * If this compilation unit already has a reference in its references table
-   * matching [dependency], [name], [numTypeParameters], and [unitNum], return
-   * its index.  Otherwise add a new reference to table and return its index.
+   * matching [dependency], [name], [numTypeParameters], [unitNum],
+   * [containingReference], and [kind], return its index.  Otherwise add a new reference to
+   * the table and return its index.
    */
-  int addReference(
-      int dependency, String name, int numTypeParameters, int unitNum) {
+  int addRawReference(String name,
+      {int dependency: 0,
+      int numTypeParameters: 0,
+      int unitNum: 0,
+      int containingReference: 0,
+      ReferenceKind kind: ReferenceKind.classOrEnum}) {
     List<LinkedReferenceBuilder> linkedReferences = _linkedUnit.references;
     List<UnlinkedReference> unlinkedReferences = _unlinkedUnit.references;
     for (int i = 0; i < linkedReferences.length; i++) {
       LinkedReferenceBuilder linkedReference = linkedReferences[i];
       if (linkedReference.dependency == dependency &&
           (i < unlinkedReferences.length
                   ? unlinkedReferences[i].name
                   : linkedReference.name) ==
               name &&
           linkedReference.numTypeParameters == numTypeParameters &&
-          linkedReference.unit == unitNum) {
+          linkedReference.unit == unitNum &&
+          (i < unlinkedReferences.length
+                  ? unlinkedReferences[i].prefixReference
+                  : linkedReference.containingReference) ==
+              containingReference &&
+          linkedReference.kind == kind) {
         return i;
       }
     }
     int result = linkedReferences.length;
     linkedReferences.add(new LinkedReferenceBuilder(
         dependency: dependency,
         name: name,
         numTypeParameters: numTypeParameters,
-        unit: unitNum));
+        unit: unitNum,
+        containingReference: containingReference,
+        kind: kind));
     return result;
   }
 
   /**
+   * If this compilation unit already has a reference in its references table
+   * to [element], return its index.  Otherwise add a new reference to the table
+   * and return its index.
+   */
+  int addReference(Element element) {
+    if (element is ClassElementForLink) {
+      return addRawReference(element.name,
+          dependency: library.addDependency(element.library),
+          numTypeParameters: element.typeParameters.length,
+          unitNum: element.enclosingElement.unitNum);
+    } else if (element is ExecutableElementForLink) {
+      // TODO(paulberry): will this code ever be executed for an executable
+      // element that's not inside a class?
+      assert(element.enclosingElement is ClassElementForLink_Class);
+      ReferenceKind kind;
+      switch (element._unlinkedExecutable.kind) {
+        case UnlinkedExecutableKind.functionOrMethod:
+          kind = ReferenceKind.method;
+          break;
+        case UnlinkedExecutableKind.setter:
+          kind = ReferenceKind.propertyAccessor;
+          break;
+        default:
+          // TODO(paulberry): implement other cases as necessary
+          throw new UnimplementedError('${element._unlinkedExecutable.kind}');
+      }
+      return addRawReference(element.name,
+          numTypeParameters: element.typeParameters.length,
+          containingReference: addReference(element.enclosingElement),
+          kind: kind);
+    }
+    // TODO(paulberry): implement other cases
+    throw new UnimplementedError('${element.runtimeType}');
+  }
+
+  /**
    * Perform type inference and const cycle detection on this
    * compilation unit.
    */
   void link() {
     if (library._linker.strongMode) {
       new InstanceMemberInferrer(enclosingElement._linker.typeProvider,
               enclosingElement.inheritanceManager)
           .inferCompilationUnit(this);
     }
     for (ClassElementForLink classElement in types) {
@@ skipping 18 matching lines @@
    * that is part of a cycle.
    */
   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) {
+  void _storeLinkedType(int slot, DartType linkedType,
+      TypeParameterContext typeParameterContext) {
     if (slot != 0) {
       if (linkedType != null && !linkedType.isDynamic) {
-        _linkedUnit.types.add(_createLinkedType(linkedType, this, slot: slot));
+        _linkedUnit.types.add(_createLinkedType(
+            linkedType, this, typeParameterContext,
+            slot: slot));
       }
     }
   }
 }
 
 /**
  * Element representing a compilation unit which is depended upon
  * (either directly or indirectly) by the build unit being linked.
  *
  * TODO(paulberry): ensure that inferred types in dependencies are properly
@@ skipping 227 matching lines @@
         parameterElement._unlinkedParam.defaultValue,
         parameterElement.compilationUnit);
     return dependencies;
   }
 }
 
 /**
  * Element representing a constructor resynthesized from a summary
  * during linking.
  */
-class ConstructorElementForLink
+class ConstructorElementForLink extends ExecutableElementForLink
     implements ConstructorElementImpl, ReferenceableElementForLink {
   /**
-   * The unlinked representation of the constructor in the summary.
-   */
-  final UnlinkedExecutable _unlinkedExecutable;
-
-  /**
    * If this is a `const` constructor and the enclosing library is
    * part of the build unit being linked, the constructor's node in
    * the constant evaluation dependency graph.  Otherwise `null`.
    */
   ConstConstructorNode _constNode;
 
-  @override
-  final ClassElementForLink_Class enclosingElement;
-
-  List<ParameterElementForLink> _parameters;
-
-  ConstructorElementForLink(this.enclosingElement, this._unlinkedExecutable) {
+  ConstructorElementForLink(ClassElementForLink_Class enclosingElement,
+      UnlinkedExecutable unlinkedExecutable)
+      : super(enclosingElement, unlinkedExecutable) {
     if (enclosingElement.enclosingElement.isInBuildUnit &&
         _unlinkedExecutable.constCycleSlot != 0) {
       _constNode = new ConstConstructorNode(this);
     }
   }
 
   @override
   ConstructorElementForLink get asConstructor => this;
 
   @override
   ConstVariableNode get asConstVariable => null;
 
   @override
   bool get isCycleFree {
     if (!_constNode.isEvaluated) {
       new ConstDependencyWalker().walk(_constNode);
     }
     return _constNode.isCycleFree;
   }
 
   @override
-  String get name => _unlinkedExecutable.name;
-
-  @override
-  List<ParameterElementForLink> get parameters {
-    if (_parameters == null) {
-      _parameters = <ParameterElementForLink>[];
-      for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
-        _parameters.add(new ParameterElementForLink(unlinkedParam,
-            enclosingElement, enclosingElement.enclosingElement));
-      }
-    }
-    return _parameters;
-  }
-
-  @override
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) =>
       UndefinedElementForLink.instance;
 
   /**
    * Perform const cycle detection on this constructor.
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     if (_constNode != null && !isCycleFree) {
       compilationUnit._storeConstCycle(_unlinkedExecutable.constCycleSlot);
     }
+    // TODO(paulberry): call super.
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Instance of [ConstNode] representing a constant field or constant
  * top level variable.
  */
@@ skipping 183 matching lines @@
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name => _unlinkedExecutable.name;
 
   @override
   List<ParameterElementForLink> get parameters {
     if (_parameters == null) {
-      _parameters = <ParameterElementForLink>[];
-      for (UnlinkedParam unlinkedParam in _unlinkedExecutable.parameters) {
-        _parameters.add(new ParameterElementForLink(
-            unlinkedParam, this, enclosingElement.enclosingElement));
+      int numParameters = _unlinkedExecutable.parameters.length;
+      _parameters = new List<ParameterElementForLink>(numParameters);
+      for (int i = 0; i < numParameters; i++) {
+        UnlinkedParam unlinkedParam = _unlinkedExecutable.parameters[i];
+        _parameters[i] = new ParameterElementForLink(
+            this, unlinkedParam, this, enclosingElement.enclosingElement, i);
       }
     }
     return _parameters;
   }
 
   @override
   DartType get returnType {
     if (_inferredReturnType != null) {
       return _inferredReturnType;
     } else if (_declaredReturnType == null) {
       if (_unlinkedExecutable.returnType == null) {
-        // In strong mode, setters without an explicit return type are
-        // considered to return `void`.
-        if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
+        if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
+          // TODO(paulberry): implement.
+          throw new UnimplementedError();
+        } else if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter &&
             library._linker.strongMode) {
+          // In strong mode, setters without an explicit return type are
+          // considered to return `void`.
           _declaredReturnType = VoidTypeImpl.instance;
         } else {
           _declaredReturnType = DynamicTypeImpl.instance;
         }
       } else {
         _declaredReturnType = enclosingElement.enclosingElement
             ._resolveTypeRef(_unlinkedExecutable.returnType, this);
       }
     }
     return _declaredReturnType;
   }
 
   @override
   void set returnType(DartType inferredType) {
     assert(_inferredReturnType == null);
     _inferredReturnType = inferredType;
   }
 
   @override
   FunctionTypeImpl get type => _type ??= new FunctionTypeImpl(this);
 
   @override
-  List<TypeParameterElementForLink> get typeParameters {
-    if (_typeParameters == null) {
-      _typeParameters = _unlinkedExecutable.typeParameters
-          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
-          .toList();
-    }
-    return _typeParameters;
-  }
+  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) {
     compilationUnit._storeLinkedType(
-        _unlinkedExecutable.inferredReturnTypeSlot, returnType);
+        _unlinkedExecutable.inferredReturnTypeSlot, returnType, this);
     for (ParameterElementForLink parameterElement in parameters) {
       parameterElement.link(compilationUnit);
     }
   }
 
   /**
    * Throw away any information produced by type inference.
    */
   void unlink() {
     for (ParameterElementForLink parameterElement in parameters) {
@@ skipping 49 matching lines @@
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
   /**
    * Store the results of type inference for this field in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     compilationUnit._storeLinkedType(
-        unlinkedVariable.inferredTypeSlot, _inferredType);
+        unlinkedVariable.inferredTypeSlot, _inferredType, enclosingElement);
   }
 
   /**
    * Throw away any information produced by type inference.
    */
   void unlink() {
     _inferredType = null;
   }
 }
 
@@ skipping 37 matching lines @@
       DynamicTypeImpl.instance;
 
   @override
   ReferenceableElementForLink getContainedName(String name) =>
       UndefinedElementForLink.instance;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
+/**
+ * Element representing a function-typed parameter resynthesied from a summary
+ * during linking.
+ */
+class FunctionElementForLink_FunctionTypedParam implements FunctionElement {
+  @override
+  final ParameterElementForLink enclosingElement;
+
+  /**
+   * The executable element containing this function-typed parameter.
+   */
+  final Element enclosingExecutable;
+
+  /**
+   * The appropriate integer list to store in
+   * [EntityRef.implicitFunctionTypeIndices] to refer to this function-typed
+   * parameter.
+   */
+  final List<int> implicitFunctionTypeIndices;
+
+  DartType _returnType;
+
+  FunctionElementForLink_FunctionTypedParam(this.enclosingElement,
+      this.enclosingExecutable, this.implicitFunctionTypeIndices);
+
+  @override
+  DartType get returnType {
+    if (_returnType == null) {
+      if (enclosingElement._unlinkedParam.type == null) {
+        _returnType = DynamicTypeImpl.instance;
+      } else {
+        _returnType = enclosingElement.compilationUnit._resolveTypeRef(
+            enclosingElement._unlinkedParam.type,
+            enclosingElement._typeParameterContext);
+      }
+    }
+    return _returnType;
+  }
+
+  @override
+  List<TypeParameterElement> get typeParameters => const [];
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
 class FunctionElementForLink_Initializer implements FunctionElementImpl {
   @override
   DartType get returnType {
     // TODO(paulberry): for type inference, compute and return the type of the
     // initializer expression.
     return DynamicTypeImpl.instance;
   }
 
   @override
   void set returnType(DartType newType) {
@@ skipping 291 matching lines @@
    * 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.
    */
   final CompilationUnitElementForLink compilationUnit;
 
+  /**
+   * The index of this parameter within [enclosingElement]'s parameter list.
+   */
+  final int _parameterIndex;
+
+  @override
+  final ExecutableElementForLink enclosingElement;
+
   DartType _inferredType;
   DartType _declaredType;
 
-  ParameterElementForLink(
-      this._unlinkedParam, this._typeParameterContext, this.compilationUnit) {
+  ParameterElementForLink(this.enclosingElement, this._unlinkedParam,
+      this._typeParameterContext, this.compilationUnit, this._parameterIndex) {
     if (_unlinkedParam.defaultValue != null) {
       _constNode = new ConstParameterNode(this);
     }
   }
 
   @override
   bool get hasImplicitType =>
       !_unlinkedParam.isFunctionTyped && _unlinkedParam.type == null;
 
   @override
+  String get name => _unlinkedParam.name;
+
+  @override
   ParameterKind get parameterKind {
     switch (_unlinkedParam.kind) {
       case UnlinkedParamKind.required:
         return ParameterKind.REQUIRED;
       case UnlinkedParamKind.positional:
         return ParameterKind.POSITIONAL;
       case UnlinkedParamKind.named:
         return ParameterKind.NAMED;
     }
   }
 
   @override
   DartType get type {
     if (_inferredType != null) {
       return _inferredType;
     } else if (_declaredType == null) {
       if (_unlinkedParam.isFunctionTyped) {
         // TODO(paulberry): implement.
-        throw new UnimplementedError();
+        _declaredType = new FunctionTypeImpl(
+            new FunctionElementForLink_FunctionTypedParam(
+                this, enclosingElement, <int>[_parameterIndex]));
       } else if (_unlinkedParam.type == null) {
         _declaredType = DynamicTypeImpl.instance;
       } else {
         _declaredType = compilationUnit._resolveTypeRef(
             _unlinkedParam.type, _typeParameterContext);
       }
     }
     return _declaredType;
   }
 
   @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
   /**
    * Store the results of type inference for this parameter in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     compilationUnit._storeLinkedType(
-        _unlinkedParam.inferredTypeSlot, _inferredType);
+        _unlinkedParam.inferredTypeSlot, _inferredType, _typeParameterContext);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
    * Throw away any information produced by type inference.
    */
   void unlink() {
     _inferredType = null;
@@ skipping 103 matching lines @@
   @override
   bool get isStatic => true;
 }
 
 /**
  * Interface representing elements which can serve as the context within which
  * type parameter indices are interpreted.
  */
 abstract class TypeParameterContext {
   /**
+   * Find out how many type parameters are in scope in this context.
+   */
+  int get typeParameterNestingLevel;
+
+  /**
    * Convert the given [index] into a type parameter type.
    */
   TypeParameterType getTypeParameterType(int index);
 }
 
 /**
  * Element representing a type parameter resynthesized from a summary during
  * linking.
  */
 class TypeParameterElementForLink implements TypeParameterElement {
   /**
    * The unlinked representation of the type parameter in the summary.
    */
   final UnlinkedTypeParam _unlinkedTypeParam;
 
-  TypeParameterElementForLink(this._unlinkedTypeParam);
+  /**
+   * The number of type parameters whose scope overlaps this one, and which are
+   * declared earlier in the file.
+   */
+  final int nestingLevel;
+
+  TypeParameterTypeImpl _type;
+
+  TypeParameterElementForLink(this._unlinkedTypeParam, this.nestingLevel);
 
   @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, TypeParameterContext {
   List<TypeParameterType> _typeParameterTypes;
   List<TypeParameterElementForLink> _typeParameters;
+  int _nestingLevel;
 
   /**
    * Get the type parameter context enclosing this one, if any.
    */
   TypeParameterContext get enclosingTypeParameterContext;
 
+  @override
+  int get typeParameterNestingLevel =>
+      _nestingLevel ??= _unlinkedTypeParams.length +
+          (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
+
   List<TypeParameterElementForLink> get typeParameters {
     if (_typeParameters == null) {
-      _typeParameters = _unlinkedTypeParams
-          .map((UnlinkedTypeParam p) => new TypeParameterElementForLink(p))
-          .toList();
+      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(
+            _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) => new TypeParameterTypeImpl(e))
+          .map((TypeParameterElementForLink e) => e.type)
           .toList();
     }
     return _typeParameterTypes;
   }
 
   /**
    * Get the [UnlinkedTypeParam]s representing the type parameters declared by
    * this element.
    */
   List<UnlinkedTypeParam> get _unlinkedTypeParams;
@@ skipping 351 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }