Add support for FieldFormalParameter.

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, 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.parser.parser;
 
 import '../scanner.dart' show
     ErrorToken;
 
 import '../scanner/recover.dart' show
@@ skipping 460 matching lines @@
     // This enables the case where `covariant` is the name of the parameter:
     //    void foo(covariant);
     if (identical(token.stringValue, 'covariant') &&
         (token.next.isIdentifier() || isModifier(token.next))) {
       token = token.next;
     }
     token = parseModifiers(token);
     // TODO(ahe): Validate that there are formal parameters if void.
     token = parseReturnTypeOpt(token);
     Token thisKeyword = null;
+    Token period = null;
     if (optional('this', token)) {
       thisKeyword = token;
+      period = token.next;

[Paul Berry, 2017/02/22 20:41:09]

This seems problematic for error recovery.  If the next token isn't a '.', we
should set period to null.

[scheglov, 2017/02/23 06:43:50]

This is the pattern that is used everywhere else in the parser.
See for example in parseDoWhileStatement().

Ideally of course we should recover just as we do in the Analyzer's
implementation, and create a synthetic token. But rewriting handling of invalid
cases and recovery seems out of scope of this CL. Might be a topic to discuss
tomorrow.

[ahe, 2017/02/23 16:27:11]

I agree that it is a problem for error recovery.

       // TODO(ahe): Validate field initializers are only used in
       // constructors, and not for function-typed arguments.
-      token = expect('.', token.next);
+      token = expect('.', period);
     }
     token = parseIdentifier(token);
     if (optional('(', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
     } else if (optional('<', token)) {
       listener.beginFunctionTypedFormalParameter(token);
       token = parseTypeVariablesOpt(token);
       token = parseFormalParameters(token);
       listener.endFunctionTypedFormalParameter(token);
     }
     String value = token.stringValue;
     if ((identical('=', value)) || (identical(':', value))) {
       // TODO(ahe): Validate that these are only used for optional parameters.
       Token equal = token;
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (type.isRequired) {
         reportRecoverableError(
             equal, ErrorKind.RequiredParameterWithDefault);
       } else if (type.isPositional && identical(':', value)) {
         reportRecoverableError(
             equal, ErrorKind.PositionalParameterWithEquals);
       }
     }
-    listener.endFormalParameter(thisKeyword);
+    listener.endFormalParameter(thisKeyword, period);

[ahe, 2017/02/23 16:27:11]

This isn't necessary. The period can be found without guessing by looking at
thisKeyword.

     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
       token = token.next;
@@ skipping 2799 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments);
     }
   }
 }