Reapply "Add support for generic function type syntax, part 1"

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

 // Copyright (c) 2016, 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.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/type.dart' show DartType;
@@ skipping 549 matching lines @@
   /**
    * Serialize the given [declaredIdentifier] into [UnlinkedVariable], and
    * store it in [variables].
    */
   void serializeDeclaredIdentifier(
       AstNode scopeNode,
       Comment documentationComment,
       NodeList<Annotation> annotations,
       bool isFinal,
       bool isConst,
-      TypeName type,
+      TypeAnnotation type,
       bool assignPropagatedTypeSlot,
       SimpleIdentifier declaredIdentifier) {
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder();
     b.isFinal = isFinal;
     b.isConst = isConst;
     b.name = declaredIdentifier.name;
     b.nameOffset = declaredIdentifier.offset;
     b.type = serializeTypeName(type);
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
@@ skipping 27 matching lines @@
    *
    * If [serializeBodyExpr] is `true`, then the function definition is stored
    * in [UnlinkedExecutableBuilder.bodyExpr].
    */
   UnlinkedExecutableBuilder serializeExecutable(
       AstNode node,
       String name,
       int nameOffset,
       bool isGetter,
       bool isSetter,
-      TypeName returnType,
+      TypeAnnotation returnType,
       FormalParameterList formalParameters,
       FunctionBody body,
       bool isTopLevel,
       bool isDeclaredStatic,
       Comment documentationComment,
       NodeList<Annotation> annotations,
       TypeParameterList typeParameters,
       bool isExternal,
       bool serializeBodyExpr,
       bool serializeBody) {
@@ skipping 128 matching lines @@
     _localClosureIndexMap = oldLocalClosureIndexMap;
     _serializeClosureBodyExprs = oldSerializeClosureBodyExprs;
     return localClosureIndexMap;
   }
 
   /**
    * Serialize the return type and parameters of a function-typed formal
    * parameter and store them in [b].
    */
   void serializeFunctionTypedParameterDetails(UnlinkedParamBuilder b,
-      TypeName returnType, FormalParameterList parameters) {
+      TypeAnnotation returnType, FormalParameterList parameters) {
     EntityRefBuilder serializedReturnType = serializeTypeName(returnType);
     if (serializedReturnType != null) {
       b.type = serializedReturnType;
     }
     bool oldMayInheritCovariance = _parametersMayInheritCovariance;
     _parametersMayInheritCovariance = false;
     b.parameters = parameters.parameters
         .map((FormalParameter p) => p.accept(this) as UnlinkedParamBuilder)
         .toList();
     _parametersMayInheritCovariance = oldMayInheritCovariance;
@@ skipping 148 matching lines @@
       return b;
     }
   }
 
   /**
    * Serialize a type name (which might be defined in a nested scope, at top
    * level within this library, or at top level within an imported library) to
    * a [EntityRef].  Note that this method does the right thing if the
    * name doesn't refer to an entity other than a type (e.g. a class member).
    */
-  EntityRefBuilder serializeTypeName(TypeName node) {
-    return serializeType(node?.name, node?.typeArguments);
+  EntityRefBuilder serializeTypeName(TypeAnnotation node) {
+    if (node is TypeName) {
+      return serializeType(node?.name, node?.typeArguments);
+    } else if (node != null) {
+      throw new ArgumentError('Cannot serialize a ${node.runtimeType}');
+    }
+    return null;
   }
 
   /**
    * Serialize the given [typeParameters] into a list of [UnlinkedTypeParam]s,
    * and also store them in [typeParameterScope].
    */
   List<UnlinkedTypeParamBuilder> serializeTypeParameters(
       TypeParameterList typeParameters,
       _TypeParameterScope typeParameterScope) {
     if (typeParameters != null) {
@@ skipping 442 matching lines @@
     return b;
   }
 
   @override
   void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     serializeVariables(
         enclosingBlock, node.variables, false, null, null, false);
   }
 
   /**
-   * Helper method to determine if a given [typeName] refers to `dynamic`.
-   */
-  static bool isDynamic(TypeName typeName) {
-    Identifier name = typeName.name;
-    return name is SimpleIdentifier && name.name == 'dynamic';
-  }
-
-  /**
    * Compute the API signature of the unit and record it.
    */
   static void _computeApiSignature(UnlinkedUnitBuilder b) {
     ApiSignature apiSignature = new ApiSignature();
     b.collectApiSignature(apiSignature);
     b.apiSignature = apiSignature.toByteList();
   }
 }
 
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }