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

pkg/analyzer/lib/dart/ast/ast_factory.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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:front_end/src/scanner/token.dart';
+import 'package:meta/meta.dart';
 
 /**
  * A collection of factory methods which may be used to create concrete
  * instances of the interfaces that constitute the AST.
  *
  * Clients should not extend, implement or mix-in this class.
  */
 abstract class AstFactory {
   /**
    * Returns a newly created list of adjacent strings. To be syntactically
@@ skipping 279 matching lines @@
    * Returns a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
   DefaultFormalParameter defaultFormalParameter(NormalFormalParameter parameter,
       ParameterKind kind, Token separator, Expression defaultValue);
 
   /**
    * Returns a documentation comment consisting of the given [tokens] and having
    * the given [references] (if supplied) embedded within it.
    */
-  Comment documentationComment(
-      List<Token> tokens, [List<CommentReference> references]);
+  Comment documentationComment(List<Token> tokens,
+      [List<CommentReference> references]);
 
   /**
    * Returns a newly created do loop.
    */
   DoStatement doStatement(
       Token doKeyword,
       Statement body,
       Token whileKeyword,
       Token leftParenthesis,
       Expression condition,
@@ skipping 93 matching lines @@
 
   /**
    * Returns a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `null` if this is not a function-typed field formal
    * parameter.
    */
   FieldFormalParameter fieldFormalParameter(

[Paul Berry, 2017/02/24 20:29:04]

Consider marking as @deprecated and adding a comment instructing clients to
start using fieldFormalParameter2.

Same for the other factory methods in this CL.

       Comment comment,
       List<Annotation> metadata,
       Token keyword,
       TypeAnnotation type,
       Token thisKeyword,
       Token period,
       SimpleIdentifier identifier,
       TypeParameterList typeParameters,
       FormalParameterList parameters);
 
   /**
+   * Returns a newly created formal parameter. Either or both of the
+   * [comment] and [metadata] can be `null` if the parameter does not have the
+   * corresponding attribute. The [keyword] can be `null` if there is a type.
+   * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
+   * [period] can be `null` if the keyword 'this' was not provided.  The
+   * [parameters] can be `null` if this is not a function-typed field formal
+   * parameter.
+   */
+  FieldFormalParameter fieldFormalParameter2(
+      {Comment comment,
+      List<Annotation> metadata,
+      Token covariantKeyword,
+      Token keyword,
+      TypeAnnotation type,
+      @required Token thisKeyword,
+      @required Token period,
+      @required SimpleIdentifier identifier,
+      TypeParameterList typeParameters,
+      FormalParameterList parameters});
+
+  /**
    * Returns a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   ForEachStatement forEachStatementWithDeclaration(
       Token awaitKeyword,
       Token forKeyword,
       Token leftParenthesis,
       DeclaredIdentifier loopVariable,
       Token inKeyword,
@@ skipping 107 matching lines @@
   FunctionTypedFormalParameter functionTypedFormalParameter(
       Comment comment,
       List<Annotation> metadata,
       TypeAnnotation returnType,
       SimpleIdentifier identifier,
       TypeParameterList typeParameters,
       FormalParameterList parameters,
       {Token question: null});
 
   /**
+   * Returns a newly created formal parameter. Either or both of the
+   * [comment] and [metadata] can be `null` if the parameter does not have the
+   * corresponding attribute. The [returnType] can be `null` if no return type
+   * was specified.
+   */
+  FunctionTypedFormalParameter functionTypedFormalParameter2(
+      {Comment comment,
+      List<Annotation> metadata,
+      Token covariantKeyword,
+      TypeAnnotation returnType,
+      @required SimpleIdentifier identifier,
+      TypeParameterList typeParameters,
+      @required FormalParameterList parameters,
+      Token question});
+
+  /**
+   * Initialize a newly created generic function type.
+   */
+  GenericFunctionType genericFunctionType(
+      TypeAnnotation returnType,
+      Token functionKeyword,
+      TypeParameterList typeParameters,
+      FormalParameterList _parameters);
+
+  /**
+   * Returns a newly created generic type alias. Either or both of the
+   * [comment] and [metadata] can be `null` if the variable list does not have
+   * the corresponding attribute. The [typeParameters] can be `null` if there
+   * are no type parameters.
+   */
+  GenericTypeAlias genericTypeAlias(
+      Comment comment,
+      List<Annotation> metadata,
+      Token typedefKeyword,
+      SimpleIdentifier name,
+      TypeParameterList typeParameters,
+      Token equals,
+      GenericFunctionType functionType,
+      Token semicolon);
+
+  /**
    * Returns a newly created import show combinator.
    */
   HideCombinator hideCombinator(
       Token keyword, List<SimpleIdentifier> hiddenNames);
 
   /**
    * Returns a newly created if statement. The [elseKeyword] and
    * [elseStatement] can be `null` if there is no else clause.
    */
   IfStatement ifStatement(
@@ skipping 275 matching lines @@
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
   SimpleFormalParameter simpleFormalParameter(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
       TypeAnnotation type,
       SimpleIdentifier identifier);
 
   /**
+   * Returns a newly created formal parameter. Either or both of the
+   * [comment] and [metadata] can be `null` if the parameter does not have the
+   * corresponding attribute. The [keyword] can be `null` if a type was
+   * specified. The [type] must be `null` if the keyword is 'var'.
+   */
+  SimpleFormalParameter simpleFormalParameter2(
+      {Comment comment,
+      List<Annotation> metadata,
+      Token covariantKeyword,
+      Token keyword,
+      TypeAnnotation type,
+      @required SimpleIdentifier identifier});
+
+  /**
    * Returns a newly created identifier.
    */
   SimpleIdentifier simpleIdentifier(Token token, {bool isDeclaration: false});
 
   /**
    * Returns a newly created simple string literal.
    */
   SimpleStringLiteral simpleStringLiteral(Token literal, String value);
 
   /**
@@ skipping 10 matching lines @@
   SuperConstructorInvocation superConstructorInvocation(
       Token superKeyword,
       Token period,
       SimpleIdentifier constructorName,
       ArgumentList argumentList);
 
   /**
    * Returns a newly created super expression.
    */
   SuperExpression superExpression(Token superKeyword);
-
   /**

[Brian Wilkerson, 2017/02/24 18:27:59]

nit: restore blank line

    * Returns a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
    */
   SwitchCase switchCase(List<Label> labels, Token keyword,
       Expression expression, Token colon, List<Statement> statements);
 
   /**
    * Returns a newly created switch default. The list of [labels] can be
    * `null` if there are no labels.
    */
   SwitchDefault switchDefault(List<Label> labels, Token keyword, Token colon,
       List<Statement> statements);
+
   /**
    * Returns a newly created switch statement. The list of [members] can be
    * `null` if there are no switch members.
    */
   SwitchStatement switchStatement(
       Token switchKeyword,
       Token leftParenthesis,
       Expression expression,
       Token rightParenthesis,
       Token leftBracket,
@@ skipping 76 matching lines @@
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
   VariableDeclarationList variableDeclarationList(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
       TypeAnnotation type,
       List<VariableDeclaration> variables);
 
   /**
-   * Returns a newly created generic type alias. Either or both of the
-   * [comment] and [metadata] can be `null` if the variable list does not have
-   * the corresponding attribute. The [typeParameters] can be `null` if there
-   * are no type parameters.
-   */
-  GenericTypeAlias genericTypeAlias(Comment comment, List<Annotation> metadata, Token typedefKeyword, SimpleIdentifier name, TypeParameterList typeParameters, Token equals, GenericFunctionType functionType, Token semicolon);
-
-  /**
-   * Initialize a newly created generic function type.
-   */
-  GenericFunctionType genericFunctionType(TypeAnnotation returnType, Token functionKeyword, TypeParameterList typeParameters, FormalParameterList _parameters);
-
-  /**
    * Returns a newly created variable declaration statement.
    */
   VariableDeclarationStatement variableDeclarationStatement(
       VariableDeclarationList variableList, Token semicolon);
 
   /**
    * Returns a newly created while statement.
    */
   WhileStatement whileStatement(Token whileKeyword, Token leftParenthesis,
       Expression condition, Token rightParenthesis, Statement body);
 
   /**
    * Returns a newly created with clause.
    */
   WithClause withClause(Token withKeyword, List<TypeName> mixinTypes);
 
   /**
    * Returns a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   YieldStatement yieldStatement(
       Token yieldKeyword, Token star, Expression expression, Token semicolon);
 }