Revert to old syntax to fix bots (TBR)

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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 analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2737 matching lines @@
    * The [optional] is `true` if the keyword and type are optional. Return the
    * 'final', 'const', 'var' or type that was parsed.
    *
    *     finalConstVarOrType ::=
    *         'final' type?
    *       | 'const' type?
    *       | 'var'
    *       | type
    */
   FinalConstVarOrType parseFinalConstVarOrType(bool optional,
-      {bool inFunctionType = false}) {
+      {bool inFunctionType: false}) {
     Token keywordToken = null;
     TypeName type = null;
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.FINAL || keyword == Keyword.CONST) {
       keywordToken = getAndAdvance();
       if (_isTypedIdentifier(_currentToken)) {
         type = parseTypeName(false);
       } else {
         // Support `final/*=T*/ x;`
         type = _parseOptionalTypeNameComment();
@@ skipping 28 matching lines @@
    * was parsed.
    *
    *     defaultFormalParameter ::=
    *         normalFormalParameter ('=' expression)?
    *
    *     defaultNamedParameter ::=
    *         normalFormalParameter ('=' expression)?
    *         normalFormalParameter (':' expression)?
    */
   FormalParameter parseFormalParameter(ParameterKind kind,
-      {bool inFunctionType = false}) {
+      {bool inFunctionType: false}) {
     NormalFormalParameter parameter =
         parseNormalFormalParameter(inFunctionType: inFunctionType);
     TokenType type = _currentToken.type;
     if (type == TokenType.EQ) {
       if (inFunctionType) {
         _reportErrorForCurrentToken(
             ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE);
       }
       Token separator = getAndAdvance();
       Expression defaultValue = parseExpression2();
@@ skipping 59 matching lines @@
    *     optionalFormalParameters ::=
    *         optionalPositionalFormalParameters
    *       | namedFormalParameters
    *
    *     optionalPositionalFormalParameters ::=
    *         '[' defaultFormalParameter (',' defaultFormalParameter)* ']'
    *
    *     namedFormalParameters ::=
    *         '{' defaultNamedParameter (',' defaultNamedParameter)* '}'
    */
-  FormalParameterList parseFormalParameterList({bool inFunctionType = false}) {
+  FormalParameterList parseFormalParameterList({bool inFunctionType: false}) {
     if (_matches(TokenType.OPEN_PAREN)) {
       return _parseFormalParameterListUnchecked(inFunctionType: inFunctionType);
     }
     // TODO(brianwilkerson) Improve the error message.
     _reportErrorForCurrentToken(
         ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_PAREN.lexeme]);
     // Recovery: Check for an unmatched closing paren and parse parameters until
     // it is reached.
     return _parseFormalParameterListAfterParen(
         _createSyntheticToken(TokenType.OPEN_PAREN));
@@ skipping 1198 matching lines @@
    *         metadata returnType? identifier typeParameters? formalParameterList
    *
    *     fieldFormalParameter ::=
    *         metadata finalConstVarOrType? 'this' '.' identifier
    *
    *     simpleFormalParameter ::=
    *         declaredIdentifier
    *       | metadata identifier
    */
   NormalFormalParameter parseNormalFormalParameter(
-      {bool inFunctionType = false}) {
+      {bool inFunctionType: false}) {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     FinalConstVarOrType holder = parseFinalConstVarOrType(!inFunctionType,
         inFunctionType: inFunctionType);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
       thisKeyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
     if (!_matchesIdentifier() && inFunctionType) {
@@ skipping 2346 matching lines @@
     }
     return astFactory.enumConstantDeclaration(
         commentAndMetadata.comment, commentAndMetadata.metadata, name);
   }
 
   /**
    * Parse a list of formal parameters given that the list starts with the given
    * [leftParenthesis]. Return the formal parameters that were parsed.
    */
   FormalParameterList _parseFormalParameterListAfterParen(Token leftParenthesis,
-      {bool inFunctionType = false}) {
+      {bool inFunctionType: false}) {
     if (_matches(TokenType.CLOSE_PAREN)) {
       return astFactory.formalParameterList(
           leftParenthesis, null, null, null, getAndAdvance());
     }
     //
     // Even though it is invalid to have default parameters outside of brackets,
     // required parameters inside of brackets, or multiple groups of default and
     // named parameters, we allow all of these cases so that we can recover
     // better.
     //
@@ skipping 143 matching lines @@
         leftSquareBracket, rightSquareBracket, rightParenthesis);
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.OPEN_PAREN`.
    */
   FormalParameterList _parseFormalParameterListUnchecked(
-      {bool inFunctionType = false}) {
+      {bool inFunctionType: false}) {
     return _parseFormalParameterListAfterParen(getAndAdvance(),
         inFunctionType: inFunctionType);
   }
 
   /**
    * Parse a function declaration statement. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [returnType] is the return type, or `null` if there is no return type.
    * Return the function declaration statement that was parsed.
    *
@@ skipping 1646 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }