Fix some corner cases of resynthesizing generic function types.

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 182 matching lines @@
 
   /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
   final Map<String, Map<String, Element>> resummarizedElements =
       <String, Map<String, Element>>{};
 
   /**
-   * Type parameters for the class or typedef currently being resynthesized.
-   *
-   * TODO(paulberry): extend this to do the right thing for generic methods.
+   * Type parameters for the generic class, typedef, or executable currently
+   * being resynthesized, if any.  If multiple entities with type parameters
+   * are nested (e.g. a generic executable inside a generic class), this is the
+   * concatenation of all type parameters from all declarations currently in
+   * force, with the outermost declaration appearing first.  If there are no
+   * type parameters, or we are not currently resynthesizing a class, typedef,
+   * or executable, then this is an empty list.
    */
-  List<TypeParameterElement> currentTypeParameters;
+  List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
 
   _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
@@ skipping 49 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, currentTypeArguments);
+              constructor, null, currentTypeArguments, false);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
       correspondingType.typeArguments = currentTypeArguments;
       classElement.type = correspondingType;
       unitHolder.addType(classElement);
     } finally {
-      currentTypeParameters = null;
+      currentTypeParameters = <TypeParameterElement>[];
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
       ShowElementCombinatorImpl combinator = new ShowElementCombinatorImpl();
       // Note: we call toList() so that we don't retain a reference to the
@@ skipping 144 matching lines @@
         assert(false);
     }
   }
 
   /**
    * Handle the parts of an executable element that are common to constructors,
    * functions, methods, getters, and setters.
    */
   void buildExecutableCommonParts(ExecutableElementImpl executableElement,
       UnlinkedExecutable serializedExecutable) {
+    List<TypeParameterType> oldTypeArguments = currentTypeArguments;
+    int oldTypeParametersLength = currentTypeParameters.length;
+    if (serializedExecutable.typeParameters.isNotEmpty) {
+      executableElement.typeParameters =
+          serializedExecutable.typeParameters.map(buildTypeParameter).toList();
+      currentTypeParameters.addAll(executableElement.typeParameters);
+    }
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.returnType != null) {
       executableElement.returnType = buildType(serializedExecutable.returnType);
     } else if (serializedExecutable.kind ==
         UnlinkedExecutableKind.constructor) {
       // Return type was set by the caller.
     } else {
       executableElement.returnType = VoidTypeImpl.instance;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
-        executableElement, null, currentTypeArguments);
+        executableElement, null, oldTypeArguments, false);
     executableElement.hasImplicitReturnType =
         serializedExecutable.hasImplicitReturnType;
     executableElement.external = serializedExecutable.isExternal;
+    currentTypeParameters.removeRange(
+        oldTypeParametersLength, currentTypeParameters.length);
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExport serializedExport) {
     ExportElementImpl exportElement = new ExportElementImpl(0);
     String exportedLibraryUri = summaryResynthesizer.sourceFactory
         .resolveUri(librarySource, serializedExport.uri)
         .uri
@@ skipping 189 matching lines @@
       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.elementWithNameAndArgs(
-          parameterTypeElement, null, currentTypeArguments);
+          parameterTypeElement, null, currentTypeArguments, false);
     } 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 24 matching lines @@
   /**
    * Build a [DartType] object based on an [UnlinkedTypeRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
   DartType buildType(UnlinkedTypeRef type) {
     if (type.paramReference != 0) {
       // TODO(paulberry): make this work for generic methods.
       return currentTypeParameters[
-              currentTypeParameters.length - type.paramReference]
-          .type;
+          currentTypeParameters.length - type.paramReference].type;
     } else {
       // TODO(paulberry): handle references to things other than classes (note:
       // this should only occur in the case of erroneous code).
       // TODO(paulberry): test reference to something inside a part.
       // TODO(paulberry): test reference to something inside a part of the
       // current lib.
       UnlinkedReference reference = unlinkedUnit.references[type.reference];
       PrelinkedReference referenceResolution =
           prelinkedUnit.references[type.reference];
       String referencedLibraryUri;
       String partUri;
       if (referenceResolution.dependency != 0) {
         PrelinkedDependency dependency =
             prelinkedLibrary.dependencies[referenceResolution.dependency];
         Source referencedLibrarySource = summaryResynthesizer.sourceFactory
             .resolveUri(librarySource, dependency.uri);
         referencedLibraryUri = referencedLibrarySource.uri.toString();
         // TODO(paulberry): consider changing Location format so that this is
         // not necessary (2nd string in location should just be the unit
         // number).
         if (referenceResolution.unit != 0) {
           UnlinkedUnit referencedLibraryDefiningUnit =
               summaryResynthesizer.getUnlinkedSummary(referencedLibraryUri);
-          String uri = referencedLibraryDefiningUnit
-              .publicNamespace.parts[referenceResolution.unit - 1].uri;
+          String uri = referencedLibraryDefiningUnit.publicNamespace.parts[
+              referenceResolution.unit - 1].uri;
           Source partSource = summaryResynthesizer.sourceFactory
               .resolveUri(referencedLibrarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       } else if (referenceResolution.kind ==
           PrelinkedReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
       } else if (reference.name.isEmpty) {
         return summaryResynthesizer.typeProvider.dynamicType;
       } else {
         referencedLibraryUri = librarySource.uri.toString();
         if (referenceResolution.unit != 0) {
-          String uri = unlinkedUnits[0]
-              .publicNamespace
-              .parts[referenceResolution.unit - 1]
-              .uri;
+          String uri = unlinkedUnits[0].publicNamespace.parts[
+              referenceResolution.unit - 1].uri;
           Source partSource =
               summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
           partUri = partSource.uri.toString();
         } else {
           partUri = referencedLibraryUri;
         }
       }
       ElementLocationImpl location = new ElementLocationImpl.con3(
           <String>[referencedLibraryUri, partUri, reference.name]);
       List<DartType> typeArguments = const <DartType>[];
@@ skipping 11 matching lines @@
         case PrelinkedReferenceKind.classOrEnum:
           return new InterfaceTypeImpl.elementWithNameAndArgs(
               new ClassElementHandle(summaryResynthesizer, location),
               reference.name,
               typeArguments);
         case PrelinkedReferenceKind.typedef:
           return new FunctionTypeImpl.elementWithNameAndArgs(
               new FunctionTypeAliasElementHandle(
                   summaryResynthesizer, location),
               reference.name,
-              typeArguments);
+              typeArguments,
+              typeArguments.isNotEmpty);
         default:
           // TODO(paulberry): figure out how to handle this case (which should
           // only occur in the event of erroneous code).
           throw new UnimplementedError();
       }
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
@@ skipping 15 matching lines @@
         functionTypeAliasElement.returnType =
             buildType(serializedTypedef.returnType);
       } else {
         functionTypeAliasElement.returnType = VoidTypeImpl.instance;
       }
       functionTypeAliasElement.type =
           new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
       functionTypeAliasElement.typeParameters = currentTypeParameters;
       unitHolder.addTypeAlias(functionTypeAliasElement);
     } finally {
-      currentTypeParameters = null;
+      currentTypeParameters = <TypeParameterElement>[];
     }
   }
 
   /**
    * Resynthesize a [TypeParameterElement], handling all parts of its except
    * its bound.
    *
    * The bound is deferred until later since it may refer to other type
    * parameters that have not been resynthesized yet.  To handle the bound,
    * call [finishTypeParameter].
@@ skipping 82 matching lines @@
     }
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     prelinkedUnit = null;
     unlinkedUnit = null;
   }
 }