Test and fix resynthesis of nested generic functions.

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 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 691 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 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.
+   * being resynthesized, if any.  This is a list of lists; if multiple
+   * entities with type parameters are nested (e.g. a generic executable inside
+   * a generic class), then the zeroth element of [currentTypeParameters]
+   * contains the type parameters for the outermost nested entity, and further
+   * elements contain the type parameters for entities that are more deeply
+   * nested.  If we are not currently resynthesizing a class, typedef, or
+   * executable, then this is an empty list.
    */
-  List<TypeParameterElement> currentTypeParameters = <TypeParameterElement>[];
+  final List<List<TypeParameterElement>> currentTypeParameters =
+      <List<TypeParameterElement>>[];
 
   /**
    * If a class is currently being resynthesized, map from field name to the
    * corresponding field element.  This is used when resynthesizing
    * initializing formal parameters.
    */
   Map<String, FieldElementImpl> fields;
 
   /**
    * If a class is currently being resynthesized, map from constructor name to
    * the corresponding constructor element.  This is used when resynthesizing
    * constructor initializers.
    */
   Map<String, ConstructorElementImpl> constructors;
 
   /**
    * List of [_ReferenceInfo] objects describing the references in the current
    * compilation unit.
    */
   List<_ReferenceInfo> referenceInfos;
 
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       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();
-
-  /**
    * Build the annotations for the given [element].
    */
   void buildAnnotations(
       ElementImpl element, List<UnlinkedConst> serializedAnnotations) {
     if (serializedAnnotations.isNotEmpty) {
       element.metadata = serializedAnnotations.map((UnlinkedConst a) {
         ElementAnnotationImpl elementAnnotation =
             new ElementAnnotationImpl(this.currentCompilationUnit);
         Expression constExpr = _buildConstExpression(a);
         if (constExpr is Identifier) {
@@ skipping 18 matching lines @@
         return elementAnnotation;
       }).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]);
-      }
       ClassElementImpl classElement = new ClassElementImpl(
           serializedClass.name, serializedClass.nameOffset);
+      classElement.typeParameters =
+          buildTypeParameters(serializedClass.typeParameters);
       classElement.abstract = serializedClass.isAbstract;
       classElement.mixinApplication = serializedClass.isMixinApplication;
       InterfaceTypeImpl correspondingType = new InterfaceTypeImpl(classElement);
       if (serializedClass.supertype != null) {
         classElement.supertype = buildType(serializedClass.supertype);
       } else if (!serializedClass.hasNoSupertype) {
         if (isCoreLibrary) {
           delayedObjectSubclasses.add(classElement);
         } else {
           classElement.supertype = summaryResynthesizer.typeProvider.objectType;
         }
       }
       classElement.interfaces =
           serializedClass.interfaces.map(buildType).toList();
       classElement.mixins = serializedClass.mixins.map(buildType).toList();
-      classElement.typeParameters = currentTypeParameters;
       ElementHolder memberHolder = new ElementHolder();
       fields = <String, FieldElementImpl>{};
       for (UnlinkedVariable serializedVariable in serializedClass.fields) {
         buildVariable(serializedVariable, memberHolder);
       }
       bool constructorFound = false;
       constructors = <String, ConstructorElementImpl>{};
       for (UnlinkedExecutable serializedExecutable
           in serializedClass.executables) {
         switch (serializedExecutable.kind) {
@@ skipping 10 matching lines @@
         }
       }
       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, false);
+              constructor, null, getCurrentTypeArguments(), false);
           memberHolder.addConstructor(constructor);
         }
         classElement.constructors = memberHolder.constructors;
       }
       classElement.accessors = memberHolder.accessors;
       classElement.fields = memberHolder.fields;
       classElement.methods = memberHolder.methods;
-      correspondingType.typeArguments = currentTypeArguments;
+      correspondingType.typeArguments = getCurrentTypeArguments();
       classElement.type = correspondingType;
       buildDocumentation(classElement, serializedClass.documentationComment);
       buildAnnotations(classElement, serializedClass.annotations);
       resolveConstructorInitializers(classElement);
       unitHolder.addType(classElement);
     } finally {
-      currentTypeParameters = <TypeParameterElement>[];
+      currentTypeParameters.removeLast();
+      assert(currentTypeParameters.isEmpty);
       fields = null;
       constructors = null;
     }
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
@@ skipping 209 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.typeParameters =
+        buildTypeParameters(serializedExecutable.typeParameters);
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.kind == UnlinkedExecutableKind.constructor) {
       // Caller handles setting the return type.
       assert(serializedExecutable.returnType == null);
     } else {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
       executableElement.returnType =
           buildLinkedType(serializedExecutable.inferredReturnTypeSlot) ??
               buildType(serializedExecutable.returnType,
                   defaultVoid: isSetter && summaryResynthesizer.strongMode);
       executableElement.hasImplicitReturnType =
           serializedExecutable.returnType == null;
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
-        executableElement, null, oldTypeArguments, false);
+        executableElement, null, getCurrentTypeArguments(skipLevels: 1), false);
     executableElement.external = serializedExecutable.isExternal;
-    currentTypeParameters.removeRange(
-        oldTypeParametersLength, currentTypeParameters.length);
     buildDocumentation(
         executableElement, serializedExecutable.documentationComment);
     buildAnnotations(executableElement, serializedExecutable.annotations);
     executableElement.functions =
         serializedExecutable.localFunctions.map(buildLocalFunction).toList();
     executableElement.localVariables =
         serializedExecutable.localVariables.map(buildLocalVariable).toList();
+    currentTypeParameters.removeLast();
   }
 
   /**
    * Resynthesize an [ExportElement],
    */
   ExportElement buildExport(UnlinkedExportPublic serializedExportPublic,
       UnlinkedExportNonPublic serializedExportNonPublic) {
     ExportElementImpl exportElement =
         new ExportElementImpl(serializedExportNonPublic.offset);
     String exportedLibraryUri = summaryResynthesizer.sourceFactory
@@ skipping 361 matching lines @@
     if (serializedParameter.isFunctionTyped) {
       FunctionElementImpl parameterTypeElement =
           new FunctionElementImpl('', -1);
       parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
       parameterTypeElement.returnType = buildType(serializedParameter.type);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
-          parameterTypeElement, null, currentTypeArguments, false);
+          parameterTypeElement, null, getCurrentTypeArguments(), false);
     } else {
       if (serializedParameter.isInitializingFormal &&
           serializedParameter.type == null) {
         // The type is inherited from the matching field.
         parameterElement.type = fields[serializedParameter.name]?.type ??
             summaryResynthesizer.typeProvider.dynamicType;
       } else {
         parameterElement.type =
             buildLinkedType(serializedParameter.inferredTypeSlot) ??
                 buildType(serializedParameter.type);
@@ skipping 52 matching lines @@
    */
   DartType buildType(EntityRef type, {bool defaultVoid: false}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return summaryResynthesizer.typeProvider.dynamicType;
       }
     }
     if (type.paramReference != 0) {
-      return currentTypeParameters[
-              currentTypeParameters.length - type.paramReference]
-          .type;
+      return getTypeParameterFromScope(type.paramReference);
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i]);
         } else {
           return summaryResynthesizer.typeProvider.dynamicType;
         }
       }
       _ReferenceInfo referenceInfo = referenceInfos[type.reference];
       return referenceInfo.buildType(
           getTypeArgument, type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     try {
-      currentTypeParameters =
-          serializedTypedef.typeParameters.map(buildTypeParameter).toList();
-      for (int i = 0; i < serializedTypedef.typeParameters.length; i++) {
-        finishTypeParameter(
-            serializedTypedef.typeParameters[i], currentTypeParameters[i]);
-      }
       FunctionTypeAliasElementImpl functionTypeAliasElement =
           new FunctionTypeAliasElementImpl(
               serializedTypedef.name, serializedTypedef.nameOffset);
+      functionTypeAliasElement.typeParameters =
+          buildTypeParameters(serializedTypedef.typeParameters);
       functionTypeAliasElement.parameters =
           serializedTypedef.parameters.map(buildParameter).toList();
       functionTypeAliasElement.returnType =
           buildType(serializedTypedef.returnType);
       functionTypeAliasElement.type =
           new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
-      functionTypeAliasElement.typeParameters = currentTypeParameters;
       buildDocumentation(
           functionTypeAliasElement, serializedTypedef.documentationComment);
       buildAnnotations(functionTypeAliasElement, serializedTypedef.annotations);
       unitHolder.addTypeAlias(functionTypeAliasElement);
     } finally {
-      currentTypeParameters = <TypeParameterElement>[];
+      currentTypeParameters.removeLast();
+      assert(currentTypeParameters.isEmpty);
     }
   }
 
   /**
    * 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].
    */
   TypeParameterElement buildTypeParameter(
       UnlinkedTypeParam serializedTypeParameter) {
     TypeParameterElementImpl typeParameterElement =
         new TypeParameterElementImpl(
             serializedTypeParameter.name, serializedTypeParameter.nameOffset);
     typeParameterElement.type = new TypeParameterTypeImpl(typeParameterElement);
     buildAnnotations(typeParameterElement, serializedTypeParameter.annotations);
     return typeParameterElement;
   }
 
   /**
+   * Build [TypeParameterElements] corresponding to the type parameters in
+   * [serializedTypeParameters] and store them in [currentTypeParameters].
+   * Also return them.
+   */
+  List<TypeParameterElement> buildTypeParameters(
+      List<UnlinkedTypeParam> serializedTypeParameters) {
+    List<TypeParameterElement> typeParameters =
+        serializedTypeParameters.map(buildTypeParameter).toList();
+    currentTypeParameters.add(typeParameters);
+    for (int i = 0; i < serializedTypeParameters.length; i++) {
+      finishTypeParameter(serializedTypeParameters[i], typeParameters[i]);
+    }
+    return typeParameters;
+  }
+
+  /**
    * Resynthesize a [TopLevelVariableElement] or [FieldElement].
    */
   void buildVariable(UnlinkedVariable serializedVariable,
       [ElementHolder holder]) {
     if (holder == null) {
       TopLevelVariableElementImpl element;
       if (serializedVariable.constExpr != null) {
         ConstTopLevelVariableElementImpl constElement =
             new ConstTopLevelVariableElementImpl(
                 serializedVariable.name, serializedVariable.nameOffset);
@@ skipping 58 matching lines @@
   void finishUnit() {
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
     referenceInfos = null;
     currentCompilationUnit = null;
   }
 
   /**
+   * Return a list of type arguments corresponding to [currentTypeParameters],
+   * skipping the innermost [skipLevels] nesting levels.
+   *
+   * Type parameters are listed in nesting order from innermost to outermost,
+   * and then in declaration order.  So for instance if we are resynthesizing a
+   * method declared as `class C<T, U> { void m<V, W>() { ... } }`, then the
+   * type parameters will be returned in the order `[V, W, T, U]`.
+   */
+  List<TypeParameterType> getCurrentTypeArguments({int skipLevels: 0}) {
+    assert(currentTypeParameters.length >= skipLevels);
+    List<TypeParameterType> result = <TypeParameterType>[];
+    for (int i = currentTypeParameters.length - 1 - skipLevels; i >= 0; i--) {
+      result.addAll(currentTypeParameters[i]
+          .map((TypeParameterElement param) => param.type));
+    }
+    return result;
+  }
+
+  /**
    * Build the components of an [ElementLocationImpl] for the entity in the
    * given [unit] of the dependency located at [dependencyIndex], and having
    * the given [name].
    */
   List<String> getReferencedLocationComponents(
       int dependencyIndex, int unit, String name) {
     if (dependencyIndex == 0) {
       String referencedLibraryUri = librarySource.uri.toString();
       String partUri;
       if (unit != 0) {
@@ skipping 16 matching lines @@
       Source partSource = summaryResynthesizer.sourceFactory
           .resolveUri(referencedLibrarySource, uri);
       partUri = partSource.uri.toString();
     } else {
       partUri = referencedLibraryUri;
     }
     return <String>[referencedLibraryUri, partUri, name];
   }
 
   /**
+   * Get the type parameter from the surrounding scope whose De Bruijn index is
+   * [index].
+   */
+  DartType getTypeParameterFromScope(int index) {
+    for (int i = currentTypeParameters.length - 1; i >= 0; i--) {
+      List<TypeParameterElement> paramsAtThisNestingLevel =
+          currentTypeParameters[i];
+      int numParamsAtThisNestingLevel = paramsAtThisNestingLevel.length;
+      if (index <= numParamsAtThisNestingLevel) {
+        return paramsAtThisNestingLevel[numParamsAtThisNestingLevel - index]
+            .type;
+      }
+      index -= numParamsAtThisNestingLevel;
+    }
+    throw new StateError('Type parameter not found');
+  }
+
+  /**
    * Populate [referenceInfos] with the correct information for the current
    * compilation unit.
    */
   void populateReferenceInfos() {
     int numLinkedReferences = linkedUnit.references.length;
     int numUnlinkedReferences = unlinkedUnit.references.length;
     referenceInfos = new List<_ReferenceInfo>(numLinkedReferences);
     for (int i = 0; i < numLinkedReferences; i++) {
       LinkedReference linkedReference = linkedUnit.references[i];
       _ReferenceInfo enclosingInfo = null;
@@ skipping 111 matching lines @@
     for (FunctionTypeAliasElement typeAlias in unit.functionTypeAliases) {
       elementMap[typeAlias.name] = typeAlias;
     }
     for (FunctionElement function in unit.functions) {
       elementMap[function.name] = function;
     }
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
+    assert(currentTypeParameters.isEmpty);
   }
 
   /**
    * Set up data structures for deserializing a compilation unit.
    */
   void prepareUnit(CompilationUnitElementImpl unit, int unitNum) {
     linkedUnit = linkedLibrary.units[unitNum];
     unlinkedUnit = unlinkedUnits[unitNum];
     linkedTypeMap = <int, EntityRef>{};
     currentCompilationUnit = unit;
@@ skipping 216 matching lines @@
                 }
               : () => this.element;
       // TODO(paulberry): Is it a bug that we have to pass `false` for
       // isInstantiated?
       return new DeferredFunctionTypeImpl(computer, null, typeArguments, false);
     } else {
       return null;
     }
   }
 }