Implement support for generic methods in summaries.

pkg/analyzer/lib/src/summary/summarize_elements.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 serialization.elements;
 
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/builder.dart';
@@ skipping 198 matching lines @@
           in exportedLibrary.exportedLibraries) {
         addTransitiveExportClosure(transitiveExport);
       }
     }
   }
 
   /**
    * Compute the appropriate De Bruijn index to represent the given type
    * parameter [type].
    */
-  int findTypeParameterIndex(TypeParameterType type) {
+  int findTypeParameterIndex(TypeParameterType type, Element context) {
     int index = 0;
-    Element enclosingElement = type.element.enclosingElement;
-    while (enclosingElement != null) {
+    while (context != null) {
       List<TypeParameterElement> typeParameters;
-      if (enclosingElement is ClassElement) {
-        typeParameters = enclosingElement.typeParameters;
-      } else if (enclosingElement is FunctionTypeAliasElement) {
-        // TODO(paulberry): test this.
-        typeParameters = enclosingElement.typeParameters;
+      if (context is ClassElement) {
+        typeParameters = context.typeParameters;
+      } else if (context is FunctionTypeAliasElement) {
+        typeParameters = context.typeParameters;
+      } else if (context is ExecutableElement) {
+        typeParameters = context.typeParameters;
       }
-      for (int i = 0; i < typeParameters.length; i++) {
-        TypeParameterElement param = typeParameters[i];
-        if (param == type.element) {
-          return index + typeParameters.length - i;
+      if (typeParameters != null) {
+        for (int i = 0; i < typeParameters.length; i++) {
+          TypeParameterElement param = typeParameters[i];
+          if (param == type.element) {
+            return index + typeParameters.length - i;
+          }
         }
+        index += typeParameters.length;
       }
-      index += typeParameters.length;
-      enclosingElement = enclosingElement.enclosingElement;
+      context = context.enclosingElement;
     }
     throw new StateError('Unbound type parameter $type');
   }
 
   /**
    * Serialize the given [classElement], which exists in the unit numbered
    * [unitNum], creating an [UnlinkedClass].
    */
   UnlinkedClassBuilder serializeClass(ClassElement classElement, int unitNum) {
     UnlinkedClassBuilder b = new UnlinkedClassBuilder(ctx);
     b.name = classElement.name;
     b.unit = unitNum;
     b.typeParameters =
         classElement.typeParameters.map(serializeTypeParam).toList();
     if (classElement.supertype != null && !classElement.supertype.isObject) {
-      b.supertype = serializeTypeRef(classElement.supertype);
+      b.supertype = serializeTypeRef(classElement.supertype, classElement);
     }
-    b.mixins = classElement.mixins.map(serializeTypeRef).toList();
-    b.interfaces = classElement.interfaces.map(serializeTypeRef).toList();
+    b.mixins = classElement.mixins
+        .map((InterfaceType t) => serializeTypeRef(t, classElement))
+        .toList();
+    b.interfaces = classElement.interfaces
+        .map((InterfaceType t) => serializeTypeRef(t, classElement))
+        .toList();
     List<UnlinkedVariableBuilder> fields = <UnlinkedVariableBuilder>[];
     List<UnlinkedExecutableBuilder> executables = <UnlinkedExecutableBuilder>[];
     for (ConstructorElement executable in classElement.constructors) {
       if (!executable.isSynthetic) {
         executables.add(serializeExecutable(executable, 0));
       }
     }
     for (MethodElement executable in classElement.methods) {
       executables.add(serializeExecutable(executable, 0));
     }
@@ skipping 91 matching lines @@
    */
   UnlinkedExecutableBuilder serializeExecutable(
       ExecutableElement executableElement, int unitNum) {
     if (executableElement.enclosingElement is ClassElement) {
       assert(unitNum == 0);
     }
     UnlinkedExecutableBuilder b = new UnlinkedExecutableBuilder(ctx);
     b.name = executableElement.name;
     b.unit = unitNum;
     if (!executableElement.type.returnType.isVoid) {
-      b.returnType = serializeTypeRef(executableElement.type.returnType);
+      b.returnType = serializeTypeRef(
+          executableElement.type.returnType, executableElement);
     }
-    // TODO(paulberry): serialize type parameters.
+    b.typeParameters =
+        executableElement.typeParameters.map(serializeTypeParam).toList();
     b.parameters =
         executableElement.type.parameters.map(serializeParam).toList();
     if (executableElement is PropertyAccessorElement) {
       if (executableElement.isGetter) {
         b.kind = UnlinkedExecutableKind.getter;
       } else {
         b.kind = UnlinkedExecutableKind.setter;
       }
     } else if (executableElement is ConstructorElement) {
       b.kind = UnlinkedExecutableKind.constructor;
@@ skipping 95 matching lines @@
         break;
       case ParameterKind.NAMED:
         b.kind = UnlinkedParamKind.named;
         break;
     }
     b.isInitializingFormal = parameter.isInitializingFormal;
     DartType type = parameter.type;
     if (type is FunctionType) {
       b.isFunctionTyped = true;
       if (!type.returnType.isVoid) {
-        b.type = serializeTypeRef(type.returnType);
+        b.type = serializeTypeRef(type.returnType, parameter);
       }
       b.parameters = type.parameters.map(serializeParam).toList();
     } else {
-      b.type = serializeTypeRef(type);
+      b.type = serializeTypeRef(type, parameter);
     }
     return b;
   }
 
   /**
    * Serialize the given [typedefElement], which exists in the unit numbered
    * [unitNum], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement, int unitNum) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder(ctx);
     b.name = typedefElement.name;
     b.unit = unitNum;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
     if (!typedefElement.returnType.isVoid) {
-      b.returnType = serializeTypeRef(typedefElement.returnType);
+      b.returnType =
+          serializeTypeRef(typedefElement.returnType, typedefElement);
     }
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
     UnlinkedTypeParamBuilder b = new UnlinkedTypeParamBuilder(ctx);
     b.name = typeParameter.name;
     if (typeParameter.bound != null) {
-      b.bound = serializeTypeRef(typeParameter.bound);
+      b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     return b;
   }
 
   /**
    * Serialize the given [type] into an [UnlinkedTypeRef].
    */
-  UnlinkedTypeRefBuilder serializeTypeRef(DartType type) {
+  UnlinkedTypeRefBuilder serializeTypeRef(DartType type, Element context) {
     UnlinkedTypeRefBuilder b = new UnlinkedTypeRefBuilder(ctx);
     if (type is TypeParameterType) {
       Element enclosingElement = type.element.enclosingElement;
-      b.paramReference = findTypeParameterIndex(type);
+      b.paramReference = findTypeParameterIndex(type, context);
     } else {
       Element element = type.element;
       CompilationUnitElement dependentCompilationUnit =
           element.getAncestor((Element e) => e is CompilationUnitElement);
       LibraryElement dependentLibrary = element.library;
       if (dependentLibrary == null) {
         assert(type.isDynamic);
         if (type is UndefinedTypeImpl) {
           b.reference = serializeUnresolvedReference();
         } else {
@@ skipping 15 matching lines @@
         });
       }
       List<DartType> typeArguments;
       if (type is InterfaceType) {
         typeArguments = type.typeArguments;
       } else if (type is FunctionType) {
         typeArguments = type.typeArguments;
       }
       if (typeArguments != null &&
           typeArguments.any((DartType argument) => !argument.isDynamic)) {
-        b.typeArguments = typeArguments.map(serializeTypeRef).toList();
+        b.typeArguments = typeArguments
+            .map((DartType t) => serializeTypeRef(t, context))
+            .toList();
       }
     }
     return b;
   }
 
   /**
    * Return the index of the entry in the references table
    * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references]) used for
    * unresolved references.  A new entry is added to the table if necessary to
    * satisfy the request.
@@ skipping 18 matching lines @@
    * a class (i.e. fields), [unitNum] should be zero.
    */
   UnlinkedVariableBuilder serializeVariable(
       PropertyInducingElement variable, int unitNum) {
     if (variable.enclosingElement is ClassElement) {
       assert(unitNum == 0);
     }
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.unit = unitNum;
-    b.type = serializeTypeRef(variable.type);
+    b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     return b;
   }
 }