Fix for summarization of generic function type aliases and support for resynthesizing.

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/ast/standard_ast_factory.dart';
@@ skipping 920 matching lines @@
     }
     ElementLocationImpl location = new ElementLocationImpl.con3(
         getReferencedLocationComponents(
             exportName.dependency, exportName.unit, name));
     switch (exportName.kind) {
       case ReferenceKind.classOrEnum:
         return new ClassElementHandle(summaryResynthesizer, location);
       case ReferenceKind.typedef:
         return new FunctionTypeAliasElementHandle(
             summaryResynthesizer, location);
+      case ReferenceKind.genericFunctionTypedef:
+        return new GenericTypeAliasElementHandle(
+            summaryResynthesizer, location);
       case ReferenceKind.topLevelFunction:
         return new FunctionElementHandle(summaryResynthesizer, location);
       case ReferenceKind.topLevelPropertyAccessor:
         return new PropertyAccessorElementHandle(
             summaryResynthesizer, location);
       case ReferenceKind.constructor:
       case ReferenceKind.function:
       case ReferenceKind.propertyAccessor:
       case ReferenceKind.method:
       case ReferenceKind.prefix:
@@ skipping 356 matching lines @@
         }
         return typeArguments;
       });
       // Mark the type as having implicit type arguments, so that we don't
       // attempt to request them during constant expression resynthesizing.
       if (typeArguments == null) {
         libraryResynthesizer.typesWithImplicitTypeArguments.add(type);
       }
       // Done.
       return type;
+    } else if (element is GenericTypeAliasElementHandle) {
+      GenericTypeAliasElementImpl actualElement = element.actualElement;
+      List<DartType> argumentTypes =
+          new List.generate(numTypeArguments, getTypeArgument);
+      return actualElement.typeAfterSubstitution(argumentTypes);
     } else if (element is FunctionTypedElement) {
       if (element is FunctionTypeAliasElementHandle) {
         List<DartType> typeArguments;
         if (numTypeArguments == numTypeParameters) {
           typeArguments =
               _buildTypeArguments(numTypeArguments, getTypeArgument);
         } else if (libraryResynthesizer.summaryResynthesizer.strongMode &&
             instantiateToBoundsAllowed) {
           FunctionType instantiatedToBounds = libraryResynthesizer
               .summaryResynthesizer.context.typeSystem
@@ skipping 505 matching lines @@
             break;
           case ReferenceKind.topLevelPropertyAccessor:
             element = new PropertyAccessorElementHandle(
                 summaryResynthesizer, location);
             break;
           case ReferenceKind.typedef:
             element = new FunctionTypeAliasElementHandle(
                 summaryResynthesizer, location);
             isDeclarableType = true;
             break;
+          case ReferenceKind.genericFunctionTypedef:
+            element = new GenericTypeAliasElementHandle(
+                summaryResynthesizer, location);
+            isDeclarableType = true;
+            break;
           case ReferenceKind.variable:
             Element enclosingElement = enclosingInfo.element;
             if (enclosingElement is ExecutableElement) {
               element = new _DeferredLocalVariableElement(
                   enclosingElement, linkedReference.localIndex);
             } else {
               throw new StateError('Unexpected element enclosing variable:'
                   ' ${enclosingElement.runtimeType}');
             }
             break;
@@ skipping 110 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }