Support for function typed formal parameters.

pkg/front_end/lib/src/fasta/analyzer/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 487 matching lines @@
 
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
     push(NullValue.ParameterDefaultValue);
   }
 
   void endFormalParameter(
       Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FormalParameter");
     _ParameterDefaultValue defaultValue = pop();
-    SimpleIdentifier name = pop();
-    TypeName type = pop();
-    Token keyword = _popOptionalSingleModifier();
-    pop(); // TODO(paulberry): Metadata.
+
+    AstNode nameOrFunctionTypedParameter = pop();
 
     FormalParameter node;
-    if (thisKeyword == null) {
-      node = ast.simpleFormalParameter2(
-          covariantKeyword: toAnalyzerToken(covariantKeyword),
-          keyword: toAnalyzerToken(keyword),
-          type: type,
-          identifier: name);
+    SimpleIdentifier name;
+    if (nameOrFunctionTypedParameter is FunctionTypedFormalParameter) {
+      node = nameOrFunctionTypedParameter;
+      name = nameOrFunctionTypedParameter.identifier;
     } else {
-      // TODO(scheglov): Ideally the period token should be passed in.
-      Token period = identical('.', thisKeyword.next?.stringValue)
-          ? thisKeyword.next
-          : null;
-      TypeParameterList typeParameters; // TODO(scheglov)
-      FormalParameterList formalParameters; // TODO(scheglov)
-      node = ast.fieldFormalParameter2(
-          covariantKeyword: toAnalyzerToken(covariantKeyword),
-          keyword: toAnalyzerToken(keyword),
-          type: type,
-          thisKeyword: toAnalyzerToken(thisKeyword),
-          period: toAnalyzerToken(period),
-          identifier: name,
-          typeParameters: typeParameters,
-          parameters: formalParameters);
+      name = nameOrFunctionTypedParameter;
+      TypeName type = pop();
+      Token keyword = _popOptionalSingleModifier();
+      pop(); // TODO(paulberry): Metadata.
+      if (thisKeyword == null) {
+        node = ast.simpleFormalParameter2(
+            covariantKeyword: toAnalyzerToken(covariantKeyword),
+            keyword: toAnalyzerToken(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;
+        TypeParameterList typeParameters; // TODO(scheglov)
+        FormalParameterList formalParameters; // TODO(scheglov)
+        node = ast.fieldFormalParameter2(
+            covariantKeyword: toAnalyzerToken(covariantKeyword),
+            keyword: toAnalyzerToken(keyword),
+            type: type,
+            thisKeyword: toAnalyzerToken(thisKeyword),
+            period: toAnalyzerToken(period),
+            identifier: name,
+            typeParameters: typeParameters,
+            parameters: formalParameters);
+      }
     }
 
     if (defaultValue != null) {
       node = ast.defaultFormalParameter(node, _toAnalyzerParameterKind(kind),
           toAnalyzerToken(defaultValue.separator), defaultValue.value);
     }
 
     scope[name.name] = name.staticElement = new AnalyzerParameterElement(node);
     push(node);
   }
 
+  @override
+  void endFunctionTypedFormalParameter(Token token) {
+    debugEvent("FunctionTypedFormalParameter");
+
+    FormalParameterList formalParameters = pop();
+    TypeParameterList typeParameters = pop();
+    SimpleIdentifier name = pop();
+    TypeName returnType = pop();
+
+    {
+      List<Token> modifiers = pop();
+      if (modifiers.isNotEmpty) {
+        // TODO(scheglov): Report error.
+        internalError('Unexpected modifier. Report an error.');
+      }
+    }
+
+    pop(); // TODO(paulberry): Metadata.
+
+    FormalParameter node;
+    node = ast.functionTypedFormalParameter2(
+        returnType: returnType,
+        identifier: name,
+        typeParameters: typeParameters,
+        parameters: formalParameters);
+
+    scope[name.name] = name.staticElement = new AnalyzerParameterElement(node);
+    push(node);
+  }
+
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
     List rawParameters = popList(count) ?? const <Object>[];
     List<FormalParameter> parameters = <FormalParameter>[];
     Token leftDelimiter;
     Token rightDelimiter;
     for (Object raw in rawParameters) {
       if (raw is _OptionalFormalParameters) {
         parameters.addAll(raw.parameters);
         leftDelimiter = raw.leftDelimiter;
@@ skipping 731 matching lines @@
 
 /// Data structure placed on the stack as a container for optional parameters.
 class _OptionalFormalParameters {
   final List<FormalParameter> parameters;
   final Token leftDelimiter;
   final Token rightDelimiter;
 
   _OptionalFormalParameters(
       this.parameters, this.leftDelimiter, this.rightDelimiter);
 }