Parse optional and named 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 'dart:collection' show Queue;
+
+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;
+import 'package:analyzer/dart/element/element.dart' show Element;
 import 'package:front_end/src/fasta/scanner/token.dart'
     show BeginGroupToken, Token;
-
-import 'package:analyzer/analyzer.dart';
-
-import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
-
-import 'package:analyzer/dart/element/element.dart' show Element;
-
-import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
-
-import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
-
 import 'package:kernel/ast.dart' show AsyncMarker;
 
 import '../errors.dart' show internalError;
-
+import '../kernel/kernel_builder.dart'
+    show Builder, KernelLibraryBuilder, ProcedureBuilder;
+import '../parser/parser.dart' show optional;
+import '../quote.dart';
+import '../source/outline_builder.dart' show asyncMarkerFromTokens;
 import '../source/scope_listener.dart'
     show JumpTargetKind, NullValue, Scope, ScopeListener;
-
-import '../kernel/kernel_builder.dart'
-    show Builder, KernelLibraryBuilder, ProcedureBuilder;
-
-import '../parser/parser.dart' show optional;
-
-import '../quote.dart';
-
-import '../source/outline_builder.dart' show asyncMarkerFromTokens;
-
+import 'analyzer.dart' show toKernel;
 import 'element_store.dart'
     show
         AnalyzerLocalVariableElemment,
         AnalyzerParameterElement,
         ElementStore,
         KernelClassElement;
-
 import 'token_utils.dart' show toAnalyzerToken;
 
-import 'analyzer.dart' show toKernel;
-
 class AstBuilder extends ScopeListener {
   final AstFactory ast = standard.astFactory;
 
   final KernelLibraryBuilder library;
 
   final Builder member;
 
   final ElementStore elementStore;
 
   bool isFirstIdentifier = false;
 
   @override
   final Uri uri;
 
   /// If `true`, the first call to [handleIdentifier] should push a
   /// List<SimpleIdentifier> on the stack, and [handleQualified] should append
   /// to the list.
   var accumulateIdentifierComponents = false;
 
+  /// The kind of current formal parameters, optional or required.
+  final Queue<ParameterKind> currentParameterKind = new Queue<ParameterKind>()
+    ..add(ParameterKind.REQUIRED);
+
+  /// The token `=` or `:` before the current parameter default value, or
+  /// `null` if not the current parameter is not default.
+  Token parameterDefaultValueToken;
+
+  /// The current parameter default value expression, or `null` if not the
+  /// current parameter is not default.
+  Expression parameterDefaultValueExpression;
+
   AstBuilder(this.library, this.member, this.elementStore, Scope scope,
       [Uri uri])
       : uri = uri ?? library.fileUri,
         super(scope);
 
   createJumpTarget(JumpTargetKind kind, int charOffset) {
     // TODO(ahe): Implement jump targets.
     return null;
   }
 
@@ skipping 419 matching lines @@
     Expression condition = pop();
     push(ast.conditionalExpression(condition, toAnalyzerToken(question),
         thenExpression, toAnalyzerToken(colon), elseExpression));
   }
 
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     push(ast.throwExpression(toAnalyzerToken(throwToken), pop()));
   }
 
+  @override
+  void beginOptionalFormalParameters(Token token) {
+    String value = token.stringValue;
+    if (identical('[', value)) {
+      currentParameterKind.addLast(ParameterKind.POSITIONAL);

[ahe, 2017/02/22 09:25:15]

I suggest that you push this on the stack instead of [currentParameterKind].

[scheglov, 2017/02/22 17:18:14]

How can I access it later?
After parsing the first parameter, the top of the stack will always be a
parameter.

What do you think about passing FormalParameterType into endFormalParameter() ?
This would require moving FormalParameterType into listener.dart, or importing
FormalParameterType into listener.dart from parser.dart.

[ahe, 2017/02/22 17:30:23]

That sounds like a good idea. We need to take advantage of having the ability to
rapidly change this API.

But we should make sure that it doesn't harm performance. Let's see what we
figure out with CL 2711463005.

+    } else if (identical('{', value)) {
+      currentParameterKind.addLast(ParameterKind.NAMED);
+    }
+  }
+
+  @override
+  void endOptionalFormalParameters(
+      int count, Token beginToken, Token endToken) {
+    debugEvent("OptionalFormalParameters");
+    currentParameterKind.removeLast();
+  }
+
+  void handleValuedFormalParameter(Token equals, Token token) {
+    debugEvent("ValuedFormalParameter");
+    parameterDefaultValueToken = equals;
+    parameterDefaultValueExpression = pop();

[ahe, 2017/02/22 09:25:15]

I would recommend against setting state in the listener as it can interfere with
error recovery. For example, try parsing this:

f([void f([x=1]) = null]) {
}

If you use pkg/front_end/lib/src/fasta/parser/bin/parser.dart, you can see all
the events generated:

MetadataStar
Modifiers
NoType
Identifier: f
NoTypeVariables
MetadataStar
Modifiers
VoidKeyword
Identifier: f
NoTypeVariables
MetadataStar
Modifiers
NoType
Identifier: x
ValuedFormalParameter
FormalParameter
OptionalFormalParameters
FormalParameters
FunctionTypedFormalParameter
ValuedFormalParameter
FormalParameter
OptionalFormalParameters
FormalParameters
AsyncModifier
TopLevelMethod
TopLevelDeclaration
CompilationUnit

Notice how ValuedFormalParameter is repeated. However, I think you're safe as
FormalParameter always follows ValuedFormalParameter. I just think it might be
easier if you put theses values on the stack, and I think all that's required is
an extra event in parseFormalParameter, for example, just before
endFormalParameter is called:

} else {
  listener.handleFormalParameterWithoutValue(token);
}

[scheglov, 2017/02/22 17:18:14]

OK, I will add handleFormalParameterWithoutValue().

+  }
+
   void endFormalParameter(Token thisKeyword) {
     debugEvent("FormalParameter");
     if (thisKeyword != null) {
       internalError("'this' can't be used here.");
     }
     SimpleIdentifier name = pop();
     TypeName type = pop();
     pop(); // Modifiers.
     pop(); // Metadata.
-    SimpleFormalParameter node = ast.simpleFormalParameter(
+    FormalParameter node = ast.simpleFormalParameter(
         null, null, toAnalyzerToken(thisKeyword), type, name);
+
+    if (parameterDefaultValueToken != null) {
+      node = ast.defaultFormalParameter(
+          node,
+          currentParameterKind.last,
+          toAnalyzerToken(parameterDefaultValueToken),
+          parameterDefaultValueExpression);
+    }
+
     scope[name.name] = name.staticElement = new AnalyzerParameterElement(node);
     push(node);
+    parameterDefaultValueToken = null;
+    parameterDefaultValueExpression = null;
   }
 
   void endFormalParameters(int count, Token beginToken, Token endToken) {
     debugEvent("FormalParameters");
     List<FormalParameter> parameters = popList(count) ?? <FormalParameter>[];
     push(ast.formalParameterList(toAnalyzerToken(beginToken), parameters, null,
         null, toAnalyzerToken(endToken)));
   }
 
   void handleCatchBlock(Token onKeyword, Token catchKeyword) {
@@ skipping 338 matching lines @@
     debugEvent("MixinApplication");
     List<TypeName> mixinTypes = pop();
     // TODO(paulberry,ahe): the parser doesn't give us enough information to
     // locate the "with" keyword.
     Token withKeyword;
     TypeName supertype = pop();
     push(new _MixinApplication(supertype, withKeyword, mixinTypes));
   }
 
   @override
-  void endNamedMixinApplication(
-      Token beginToken, Token equalsToken, Token implementsKeyword, Token endToken) {
+  void endNamedMixinApplication(Token beginToken, Token equalsToken,
+      Token implementsKeyword, Token endToken) {
     debugEvent("NamedMixinApplication");
     ImplementsClause implementsClause;
     if (implementsKeyword != null) {
       List<TypeName> interfaces = pop();
       implementsClause =
           ast.implementsClause(toAnalyzerToken(implementsKeyword), interfaces);
     }
     _MixinApplication mixinApplication = pop();
     var superclass = mixinApplication.supertype;
     var withClause = ast.withClause(
@@ skipping 271 matching lines @@
 /// [ClassDeclaration] or [ClassTypeAlias] object.
 class _MixinApplication {
   final TypeName supertype;
 
   final Token withKeyword;
 
   final List<TypeName> mixinTypes;
 
   _MixinApplication(this.supertype, this.withKeyword, this.mixinTypes);
 }