Mark not-optional-parameters methods of AstFactory as deprecated.

pkg/analyzer/lib/src/generated/testing/ast_test_factory.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.testing.ast_test_factory;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 466 matching lines @@
           fieldList: variableDeclarationList(keyword, type, variables),
           semicolon: TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static FieldDeclaration fieldDeclaration2(bool isStatic, Keyword keyword,
           List<VariableDeclaration> variables) =>
       fieldDeclaration(isStatic, keyword, null, variables);
 
   static FieldFormalParameter fieldFormalParameter(
           Keyword keyword, TypeAnnotation type, String identifier,
           [FormalParameterList parameterList]) =>
-      astFactory.fieldFormalParameter(
-          null,
-          null,
-          keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
-          type,
-          TokenFactory.tokenFromKeyword(Keyword.THIS),
-          TokenFactory.tokenFromType(TokenType.PERIOD),
-          identifier3(identifier),
-          null,
-          parameterList);
+      astFactory.fieldFormalParameter2(
+          keyword:
+              keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
+          type: type,
+          thisKeyword: TokenFactory.tokenFromKeyword(Keyword.THIS),
+          period: TokenFactory.tokenFromType(TokenType.PERIOD),
+          identifier: identifier3(identifier),
+          parameters: parameterList);
 
   static FieldFormalParameter fieldFormalParameter2(String identifier) =>
       fieldFormalParameter(null, null, identifier);
 
   static ForEachStatement forEachStatement(DeclaredIdentifier loopVariable,
           Expression iterator, Statement body) =>
       astFactory.forEachStatementWithDeclaration(
           null,
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
@@ skipping 95 matching lines @@
   static FunctionExpressionInvocation functionExpressionInvocation2(
           Expression function,
           [TypeArgumentList typeArguments,
           List<Expression> arguments]) =>
       astFactory.functionExpressionInvocation(
           function, typeArguments, argumentList(arguments));
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
           TypeAnnotation returnType, String identifier,
           [List<FormalParameter> parameters]) =>
-      astFactory.functionTypedFormalParameter(null, null, returnType,
-          identifier3(identifier), null, formalParameterList(parameters));
+      astFactory.functionTypedFormalParameter2(
+          returnType: returnType,
+          identifier: identifier3(identifier),
+          parameters: formalParameterList(parameters));
 
   static HideCombinator hideCombinator(List<SimpleIdentifier> identifiers) =>
       astFactory.hideCombinator(
           TokenFactory.tokenFromString("hide"), identifiers);
 
   static HideCombinator hideCombinator2(List<String> identifiers) =>
       astFactory.hideCombinator(
           TokenFactory.tokenFromString("hide"), identifierList(identifiers));
 
   static PrefixedIdentifier identifier(
@@ skipping 434 matching lines @@
   static ShowCombinator showCombinator2(List<String> identifiers) =>
       astFactory.showCombinator(
           TokenFactory.tokenFromString("show"), identifierList(identifiers));
 
   static SimpleFormalParameter simpleFormalParameter(
           Keyword keyword, String parameterName) =>
       simpleFormalParameter2(keyword, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter2(
           Keyword keyword, TypeAnnotation type, String parameterName) =>
-      astFactory.simpleFormalParameter(
-          null,
-          null,
-          keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
-          type,
-          identifier3(parameterName));
+      astFactory.simpleFormalParameter2(
+          keyword:
+              keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
+          type: type,
+          identifier: identifier3(parameterName));
 
   static SimpleFormalParameter simpleFormalParameter3(String parameterName) =>
       simpleFormalParameter2(null, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter4(
           TypeAnnotation type, String parameterName) =>
       simpleFormalParameter2(null, type, parameterName);
 
   static StringInterpolation string([List<InterpolationElement> elements]) =>
       astFactory.stringInterpolation(elements);
@@ skipping 231 matching lines @@
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(Expression expression) =>
       astFactory.yieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           null,
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }