Implement type variables on old style function-typed formal parameters.

pkg/analyzer/lib/src/fasta/ast_builder.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 fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
@@ skipping 815 matching lines @@
           rightParenthesis,
           body));
     }
   }
 
   void endFormalParameter(Token thisKeyword, Token nameToken,
       FormalParameterType kind, MemberKind memberKind) {
     debugEvent("FormalParameter");
     _ParameterDefaultValue defaultValue = pop();
 
-    AstNode nameOrFunctionTypedParameter = pop();
+    SimpleIdentifier name = pop();
+
+    AstNode typeOrFunctionTypedParameter = pop();
+
+    _Modifiers modifiers = pop();
+    Token keyword = modifiers?.finalConstOrVarKeyword;
+    Token covariantKeyword = modifiers?.covariantKeyword;
+    pop(); // TODO(paulberry): Metadata.
+    Comment comment = pop();
 
     FormalParameter node;
-    SimpleIdentifier name;
-    if (nameOrFunctionTypedParameter is FormalParameter) {
-      node = nameOrFunctionTypedParameter;
-      name = nameOrFunctionTypedParameter.identifier;
+    if (typeOrFunctionTypedParameter is FunctionTypedFormalParameter) {
+      // This is a temporary AST node that was constructed in
+      // [endFunctionTypedFormalParameter]. We now deconstruct it and create
+      // the final AST node.
+      if (thisKeyword == null) {
+        node = ast.functionTypedFormalParameter2(
+            identifier: name,
+            comment: comment,
+            covariantKeyword: covariantKeyword,
+            returnType: typeOrFunctionTypedParameter.returnType,
+            typeParameters: typeOrFunctionTypedParameter.typeParameters,
+            parameters: typeOrFunctionTypedParameter.parameters);
+      } else {
+        node = ast.fieldFormalParameter2(
+            identifier: name,
+            comment: comment,
+            covariantKeyword: covariantKeyword,
+            type: typeOrFunctionTypedParameter.returnType,
+            thisKeyword: thisKeyword,
+            period: thisKeyword.next,
+            typeParameters: typeOrFunctionTypedParameter.typeParameters,
+            parameters: typeOrFunctionTypedParameter.parameters);
+      }
     } else {
-      name = nameOrFunctionTypedParameter;
-      TypeAnnotation type = pop();
-      _Modifiers modifiers = pop();
-      Token keyword = modifiers?.finalConstOrVarKeyword;
-      Token covariantKeyword = modifiers?.covariantKeyword;
-      pop(); // TODO(paulberry): Metadata.
-      Comment comment = pop();
+      TypeAnnotation type = typeOrFunctionTypedParameter;
       if (thisKeyword == null) {
         node = ast.simpleFormalParameter2(
             comment: comment,
             covariantKeyword: covariantKeyword,
             keyword: keyword,
             type: type,
             identifier: name);
       } else {
-        // TODO(scheglov): Ideally the period token should be passed in.
-        Token period = identical('.', thisKeyword.next?.stringValue)
-            ? thisKeyword.next
-            : null;
         node = ast.fieldFormalParameter2(
             comment: comment,
             covariantKeyword: covariantKeyword,
             keyword: keyword,
             type: type,
             thisKeyword: thisKeyword,
-            period: period,
+            period: thisKeyword.next,
             identifier: name);
       }
     }
 
     ParameterKind analyzerKind = _toAnalyzerParameterKind(kind);
     if (analyzerKind != ParameterKind.REQUIRED) {
       node = ast.defaultFormalParameter(
           node, analyzerKind, defaultValue?.separator, defaultValue?.value);
     }
 
     if (name != null) {
       scope.declare(
           name.name,
           name.staticElement = new AnalyzerParameterElement(node),
           name.offset,
           uri);
     }
     push(node);
   }
 
   @override
-  void endFunctionTypedFormalParameter(
-      Token thisKeyword, FormalParameterType kind) {
+  void endFunctionTypedFormalParameter() {
     debugEvent("FunctionTypedFormalParameter");
 
     FormalParameterList formalParameters = pop();
+    TypeAnnotation returnType = pop();
     TypeParameterList typeParameters = pop();
-    SimpleIdentifier name = pop();
-    TypeAnnotation returnType = pop();
 
-    _Modifiers modifiers = pop();
-    Token covariantKeyword = modifiers?.covariantKeyword;
-
-    pop(); // TODO(paulberry): Metadata.
-    Comment comment = pop();
-
-    FormalParameter node;
-    if (thisKeyword == null) {
-      node = ast.functionTypedFormalParameter2(
-          comment: comment,
-          covariantKeyword: covariantKeyword,
-          returnType: returnType,
-          identifier: name,
-          typeParameters: typeParameters,
-          parameters: formalParameters);
-    } else {
-      // TODO(scheglov): Ideally the period token should be passed in.
-      Token period = identical('.', thisKeyword?.next?.stringValue)
-          ? thisKeyword.next
-          : null;
-      node = ast.fieldFormalParameter2(
-          comment: comment,
-          covariantKeyword: covariantKeyword,
-          type: returnType,
-          thisKeyword: thisKeyword,
-          period: period,
-          identifier: name,
-          typeParameters: typeParameters,
-          parameters: formalParameters);
-    }
-
-    scope.declare(
-        name.name,
-        name.staticElement = new AnalyzerParameterElement(node),
-        name.offset,
-        uri);
-    push(node);
+    // Create a temporary formal parameter that will be dissected later in
+    // [endFormalParameter].
+    push(ast.functionTypedFormalParameter2(
+        identifier: null,
+        returnType: returnType,
+        typeParameters: typeParameters,
+        parameters: formalParameters));
   }
 
   void endFormalParameters(
       int count, Token beginToken, Token endToken, MemberKind kind) {
     debugEvent("FormalParameters");
     List rawParameters = popList(count) ?? const <Object>[];
     List<FormalParameter> parameters = <FormalParameter>[];
     Token leftDelimiter;
     Token rightDelimiter;
     for (Object raw in rawParameters) {
@@ skipping 1092 matching lines @@
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('covariant', s)) {
         covariantKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }