Add AST factories for formal parameters with all optional named parameters.

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 4145 matching lines @@
     }
     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) {
-      SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
-          commentAndMetadata.comment,
-          commentAndMetadata.metadata,
-          holder.keyword,
-          holder.type,
-          null);
-      parameter.covariantKeyword = covariantKeyword;
-      return parameter;
+      return astFactory.simpleFormalParameter2(
+          comment: commentAndMetadata.comment,
+          metadata: commentAndMetadata.metadata,
+          covariantKeyword: covariantKeyword,
+          keyword: holder.keyword,
+          type: holder.type,
+          identifier: null);
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         Token question = null;
         if (enableNnbd && _matches(TokenType.QUESTION)) {
           question = getAndAdvance();
         }
-        FunctionTypedFormalParameterImpl parameter =
-            astFactory.functionTypedFormalParameter(
-                commentAndMetadata.comment,
-                commentAndMetadata.metadata,
-                holder.type,
-                astFactory.simpleIdentifier(identifier.token,
-                    isDeclaration: true),
-                typeParameters,
-                parameters,
-                question: question);
-        parameter.covariantKeyword = covariantKeyword;
-        return parameter;
+        return astFactory.functionTypedFormalParameter2(
+            comment: commentAndMetadata.comment,
+            metadata: commentAndMetadata.metadata,
+            covariantKeyword: covariantKeyword,
+            returnType: holder.type,
+            identifier: astFactory.simpleIdentifier(identifier.token,
+                isDeclaration: true),
+            typeParameters: typeParameters,
+            parameters: parameters,
+            question: question);
       } else {
-        FieldFormalParameterImpl parameter = astFactory.fieldFormalParameter(
-            commentAndMetadata.comment,
-            commentAndMetadata.metadata,
-            holder.keyword,
-            holder.type,
-            thisKeyword,
-            period,
-            identifier,
-            typeParameters,
-            parameters);
-        parameter.covariantKeyword = covariantKeyword;
-        return parameter;
+        return astFactory.fieldFormalParameter2(
+            comment: commentAndMetadata.comment,
+            metadata: commentAndMetadata.metadata,
+            covariantKeyword: covariantKeyword,
+            keyword: holder.keyword,
+            type: holder.type,
+            thisKeyword: thisKeyword,
+            period: period,
+            identifier: identifier,
+            typeParameters: typeParameters,
+            parameters: parameters);
       }
     } else if (typeParameters != null) {
       // TODO(brianwilkerson) Report an error. It looks like a function-typed
       // parameter with no parameter list.
       //_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
     }
     TypeAnnotation type = holder.type;
     if (type != null) {
       if (type is TypeName &&
           _tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
         _reportErrorForToken(
             ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
       } else if (holder.keyword != null &&
           _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
         _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
       }
     }
     if (thisKeyword != null) {
       // TODO(brianwilkerson) If there are type parameters but no parameters,
       // should we create a synthetic empty parameter list here so we can
       // capture the type parameters?
-      FieldFormalParameterImpl parameter = astFactory.fieldFormalParameter(
-          commentAndMetadata.comment,
-          commentAndMetadata.metadata,
-          holder.keyword,
-          type,
-          thisKeyword,
-          period,
-          identifier,
-          null,
-          null);
-      parameter.covariantKeyword = covariantKeyword;
-      return parameter;
+      return astFactory.fieldFormalParameter2(
+          comment: commentAndMetadata.comment,
+          metadata: commentAndMetadata.metadata,
+          covariantKeyword: covariantKeyword,
+          keyword: holder.keyword,
+          type: type,
+          thisKeyword: thisKeyword,
+          period: period,
+          identifier: identifier);
     }
-    SimpleFormalParameterImpl parameter = astFactory.simpleFormalParameter(
-        commentAndMetadata.comment,
-        commentAndMetadata.metadata,
-        holder.keyword,
-        type,
-        astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
-    parameter.covariantKeyword = covariantKeyword;
-    return parameter;
+    return astFactory.simpleFormalParameter2(
+        comment: commentAndMetadata.comment,
+        metadata: commentAndMetadata.metadata,
+        covariantKeyword: covariantKeyword,
+        keyword: holder.keyword,
+        type: type,
+        identifier:
+            astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
   }
 
   /**
    * Parse an operator declaration. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [externalKeyword] is the 'external' token. The [returnType] is the
    * return type that has already been parsed, or `null` if there was no return
    * type. Return the operator declaration that was parsed.
    *
    *     operatorDeclaration ::=
@@ skipping 4244 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }