Test and fix resynthesized function-typed parameters referring to type parameters.

pkg/analyzer/lib/src/summary/resynthesize.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library summary_resynthesizer;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/element_handle.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 194 matching lines @@
    * TODO(paulberry): extend this to do the right thing for generic methods.
    */
   List<TypeParameterElement> currentTypeParameters;
 
   _LibraryResynthesizer(this.summaryResynthesizer, this.prelinkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
   /**
+   * Return a list of type arguments corresponding to [currentTypeParameters].
+   */
+  List<TypeParameterType> get currentTypeArguments => currentTypeParameters
+      ?.map((TypeParameterElement param) => param.type)
+      ?.toList();
+
+  /**
    * Resynthesize a [ClassElement] and place it in [unitHolder].
    */
   void buildClass(UnlinkedClass serializedClass) {
     try {
       currentTypeParameters =
           serializedClass.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedClass.typeParameters.length; i++) {
         finishTypeParameter(
             serializedClass.typeParameters[i], currentTypeParameters[i]);
       }
@@ skipping 34 matching lines @@
         buildVariable(serializedVariable, memberHolder);
       }
       if (!serializedClass.isMixinApplication) {
         if (!constructorFound) {
           // Synthesize implicit constructors.
           ConstructorElementImpl constructor =
               new ConstructorElementImpl('', -1);
           constructor.synthetic = true;
           constructor.returnType = correspondingType;
           constructor.type = new FunctionTypeImpl.elementWithNameAndArgs(
-              constructor,
-              null,
-              currentTypeParameters
-                  .map((TypeParameterElement e) => e.type)
-                  .toList());
+              constructor, null, currentTypeArguments);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
-      correspondingType.typeArguments =
-          currentTypeParameters.map((param) => param.type).toList();
+      correspondingType.typeArguments = currentTypeArguments;
       classElement.type = correspondingType;
       unitHolder.addType(classElement);
     } finally {
       currentTypeParameters = null;
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
@@ skipping 153 matching lines @@
   void buildExecutableCommonParts(ExecutableElementImpl executableElement,
       UnlinkedExecutable serializedExecutable) {
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.returnType != null) {
       executableElement.returnType = buildType(serializedExecutable.returnType);
     } else {
       executableElement.returnType = VoidTypeImpl.instance;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
-        executableElement,
-        null,
-        currentTypeParameters
-            ?.map((TypeParameterElement e) => e.type)
-            ?.toList());
+        executableElement, null, currentTypeArguments);
     executableElement.hasImplicitReturnType =
         serializedExecutable.hasImplicitReturnType;
     executableElement.external = serializedExecutable.isExternal;
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExport serializedExport) {
     ExportElementImpl exportElement = new ExportElementImpl(0);
@@ skipping 190 matching lines @@
       parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       if (serializedParameter.type != null) {
         parameterTypeElement.returnType = buildType(serializedParameter.type);
       } else {
         parameterTypeElement.returnType = VoidTypeImpl.instance;
       }
-      parameterElement.type = new FunctionTypeImpl(parameterTypeElement);
+      parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
+          parameterTypeElement, null, currentTypeArguments);
     } else {
       parameterElement.type = buildType(serializedParameter.type);
       parameterElement.hasImplicitType = serializedParameter.hasImplicitType;
     }
     switch (serializedParameter.kind) {
       case UnlinkedParamKind.named:
         parameterElement.parameterKind = ParameterKind.NAMED;
         break;
       case UnlinkedParamKind.positional:
         parameterElement.parameterKind = ParameterKind.POSITIONAL;
@@ skipping 235 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }