diff --git a/pkg/analysis_server/lib/src/services/completion/dart/completion_manager.dart b/pkg/analysis_server/lib/src/services/completion/dart/completion_manager.dart index e00ec2a81a5..26a9af5c403 100644 --- a/pkg/analysis_server/lib/src/services/completion/dart/completion_manager.dart +++ b/pkg/analysis_server/lib/src/services/completion/dart/completion_manager.dart @@ -19,6 +19,7 @@ import 'package:analysis_server/src/services/completion/dart/contribution_sorter import 'package:analysis_server/src/services/completion/dart/optype.dart'; import 'package:analysis_server/src/services/search/search_engine.dart'; 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'; import 'package:analyzer/dart/element/type.dart'; @@ -516,7 +517,8 @@ class ReplacementRange { } } if (token is StringToken) { - SimpleStringLiteral uri = new SimpleStringLiteral(token, token.lexeme); + SimpleStringLiteral uri = + astFactory.simpleStringLiteral(token, token.lexeme); Keyword keyword = token.previous?.keyword; if (keyword == Keyword.IMPORT || keyword == Keyword.EXPORT || diff --git a/pkg/analysis_server/lib/src/services/completion/dart/label_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/label_contributor.dart index 8600be2e9ea..a540887fd60 100644 --- a/pkg/analysis_server/lib/src/services/completion/dart/label_contributor.dart +++ b/pkg/analysis_server/lib/src/services/completion/dart/label_contributor.dart @@ -15,6 +15,7 @@ import 'package:analysis_server/src/services/completion/dart/local_declaration_v show LocalDeclarationVisitor; import 'package:analysis_server/src/services/completion/dart/optype.dart'; 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/src/dart/ast/token.dart'; import 'package:analyzer/src/generated/source.dart'; @@ -24,8 +25,9 @@ import '../../../protocol_server.dart' const DYNAMIC = 'dynamic'; -final TypeName NO_RETURN_TYPE = new TypeName( - new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), null); +final TypeName NO_RETURN_TYPE = astFactory.typeName( + astFactory.simpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), + null); /** * Create a new protocol Element for inclusion in a completion suggestion. diff --git a/pkg/analysis_server/lib/src/services/completion/dart/local_constructor_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/local_constructor_contributor.dart index 8778f6c22ef..cef91def59f 100644 --- a/pkg/analysis_server/lib/src/services/completion/dart/local_constructor_contributor.dart +++ b/pkg/analysis_server/lib/src/services/completion/dart/local_constructor_contributor.dart @@ -16,6 +16,7 @@ import 'package:analysis_server/src/services/completion/dart/local_declaration_v import 'package:analysis_server/src/services/completion/dart/optype.dart'; import 'package:analysis_server/src/services/completion/dart/suggestion_builder.dart'; 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'; import 'package:analyzer/src/dart/ast/token.dart'; @@ -26,8 +27,9 @@ import '../../../protocol_server.dart' const DYNAMIC = 'dynamic'; -final TypeName NO_RETURN_TYPE = new TypeName( - new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), null); +final TypeName NO_RETURN_TYPE = astFactory.typeName( + astFactory.simpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), + null); /** * Create a new protocol Element for inclusion in a completion suggestion. diff --git a/pkg/analysis_server/lib/src/services/completion/dart/local_declaration_visitor.dart b/pkg/analysis_server/lib/src/services/completion/dart/local_declaration_visitor.dart index f0c2b3a1192..adf26c7ab6f 100644 --- a/pkg/analysis_server/lib/src/services/completion/dart/local_declaration_visitor.dart +++ b/pkg/analysis_server/lib/src/services/completion/dart/local_declaration_visitor.dart @@ -5,6 +5,7 @@ library services.completion.dart.local.declaration.visitor; 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/ast/visitor.dart'; import 'package:analyzer/src/dart/ast/token.dart'; @@ -15,8 +16,8 @@ import 'package:analyzer/src/dart/ast/token.dart'; * which catches the exception thrown by [finished()]. */ abstract class LocalDeclarationVisitor extends GeneralizingAstVisitor { - static final TypeName STACKTRACE_TYPE = new TypeName( - new SimpleIdentifier( + static final TypeName STACKTRACE_TYPE = astFactory.typeName( + astFactory.simpleIdentifier( new StringToken(TokenType.IDENTIFIER, 'StackTrace', 0)), null); diff --git a/pkg/analysis_server/lib/src/services/completion/dart/local_reference_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/local_reference_contributor.dart index 70b2b448e4e..01298f86515 100644 --- a/pkg/analysis_server/lib/src/services/completion/dart/local_reference_contributor.dart +++ b/pkg/analysis_server/lib/src/services/completion/dart/local_reference_contributor.dart @@ -17,6 +17,7 @@ import 'package:analysis_server/src/services/completion/dart/optype.dart'; import 'package:analysis_server/src/services/correction/strings.dart'; import 'package:analysis_server/src/utilities/documentation.dart'; 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'; import 'package:analyzer/dart/element/type.dart'; @@ -29,8 +30,9 @@ import '../../../protocol_server.dart' const DYNAMIC = 'dynamic'; -final TypeName NO_RETURN_TYPE = new TypeName( - new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), null); +final TypeName NO_RETURN_TYPE = astFactory.typeName( + astFactory.simpleIdentifier(new StringToken(TokenType.IDENTIFIER, '', 0)), + null); /** * Create a new protocol Element for inclusion in a completion suggestion. diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart index 7dd0e48010e..3efd68b2489 100644 --- a/pkg/analyzer/lib/src/dart/ast/utilities.dart +++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart @@ -7,6 +7,7 @@ library analyzer.src.dart.ast.utilities; import 'dart:collection'; 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/ast/visitor.dart'; import 'package:analyzer/dart/element/element.dart'; @@ -120,10 +121,10 @@ class AstCloner implements AstVisitor { @override AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => - new AdjacentStrings(cloneNodeList(node.strings)); + astFactory.adjacentStrings(cloneNodeList(node.strings)); @override - Annotation visitAnnotation(Annotation node) => new Annotation( + Annotation visitAnnotation(Annotation node) => astFactory.annotation( cloneToken(node.atSign), cloneNode(node.name), cloneToken(node.period), @@ -131,20 +132,20 @@ class AstCloner implements AstVisitor { cloneNode(node.arguments)); @override - ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList( + ArgumentList visitArgumentList(ArgumentList node) => astFactory.argumentList( cloneToken(node.leftParenthesis), cloneNodeList(node.arguments), cloneToken(node.rightParenthesis)); @override - AsExpression visitAsExpression(AsExpression node) => new AsExpression( + AsExpression visitAsExpression(AsExpression node) => astFactory.asExpression( cloneNode(node.expression), cloneToken(node.asOperator), cloneNode(node.type)); @override AstNode visitAssertInitializer(AssertInitializer node) => - new AssertInitializer( + astFactory.assertInitializer( cloneToken(node.assertKeyword), cloneToken(node.leftParenthesis), cloneNode(node.condition), @@ -153,56 +154,56 @@ class AstCloner implements AstVisitor { cloneToken(node.rightParenthesis)); @override - AstNode visitAssertStatement(AssertStatement node) => new AssertStatement( - cloneToken(node.assertKeyword), - cloneToken(node.leftParenthesis), - cloneNode(node.condition), - cloneToken(node.comma), - cloneNode(node.message), - cloneToken(node.rightParenthesis), - cloneToken(node.semicolon)); + AstNode visitAssertStatement(AssertStatement node) => + astFactory.assertStatement( + cloneToken(node.assertKeyword), + cloneToken(node.leftParenthesis), + cloneNode(node.condition), + cloneToken(node.comma), + cloneNode(node.message), + cloneToken(node.rightParenthesis), + cloneToken(node.semicolon)); @override AssignmentExpression visitAssignmentExpression(AssignmentExpression node) => - new AssignmentExpression(cloneNode(node.leftHandSide), + astFactory.assignmentExpression(cloneNode(node.leftHandSide), cloneToken(node.operator), cloneNode(node.rightHandSide)); @override AwaitExpression visitAwaitExpression(AwaitExpression node) => - new AwaitExpression( + astFactory.awaitExpression( cloneToken(node.awaitKeyword), cloneNode(node.expression)); @override BinaryExpression visitBinaryExpression(BinaryExpression node) => - new BinaryExpression(cloneNode(node.leftOperand), + astFactory.binaryExpression(cloneNode(node.leftOperand), cloneToken(node.operator), cloneNode(node.rightOperand)); @override - Block visitBlock(Block node) => new Block(cloneToken(node.leftBracket), + Block visitBlock(Block node) => astFactory.block(cloneToken(node.leftBracket), cloneNodeList(node.statements), cloneToken(node.rightBracket)); @override BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => - new BlockFunctionBody(cloneToken(node.keyword), cloneToken(node.star), - cloneNode(node.block)); + astFactory.blockFunctionBody(cloneToken(node.keyword), + cloneToken(node.star), cloneNode(node.block)); @override BooleanLiteral visitBooleanLiteral(BooleanLiteral node) => - new BooleanLiteral(cloneToken(node.literal), node.value); + astFactory.booleanLiteral(cloneToken(node.literal), node.value); @override - BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement( - cloneToken(node.breakKeyword), - cloneNode(node.label), - cloneToken(node.semicolon)); + BreakStatement visitBreakStatement(BreakStatement node) => + astFactory.breakStatement(cloneToken(node.breakKeyword), + cloneNode(node.label), cloneToken(node.semicolon)); @override CascadeExpression visitCascadeExpression(CascadeExpression node) => - new CascadeExpression( + astFactory.cascadeExpression( cloneNode(node.target), cloneNodeList(node.cascadeSections)); @override - CatchClause visitCatchClause(CatchClause node) => new CatchClause( + CatchClause visitCatchClause(CatchClause node) => astFactory.catchClause( cloneToken(node.onKeyword), cloneNode(node.exceptionType), cloneToken(node.catchKeyword), @@ -215,7 +216,7 @@ class AstCloner implements AstVisitor { @override ClassDeclaration visitClassDeclaration(ClassDeclaration node) { - ClassDeclaration copy = new ClassDeclaration( + ClassDeclaration copy = astFactory.classDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.abstractKeyword), @@ -235,7 +236,7 @@ class AstCloner implements AstVisitor { @override ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) { cloneToken(node.abstractKeyword); - return new ClassTypeAlias( + return astFactory.classTypeAlias( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.typedefKeyword), @@ -252,22 +253,22 @@ class AstCloner implements AstVisitor { @override Comment visitComment(Comment node) { if (node.isDocumentation) { - return Comment.createDocumentationCommentWithReferences( + return astFactory.documentationComment( cloneTokenList(node.tokens), cloneNodeList(node.references)); } else if (node.isBlock) { - return Comment.createBlockComment(cloneTokenList(node.tokens)); + return astFactory.blockComment(cloneTokenList(node.tokens)); } - return Comment.createEndOfLineComment(cloneTokenList(node.tokens)); + return astFactory.endOfLineComment(cloneTokenList(node.tokens)); } @override CommentReference visitCommentReference(CommentReference node) => - new CommentReference( + astFactory.commentReference( cloneToken(node.newKeyword), cloneNode(node.identifier)); @override CompilationUnit visitCompilationUnit(CompilationUnit node) { - CompilationUnit clone = new CompilationUnit( + CompilationUnit clone = astFactory.compilationUnit( cloneToken(node.beginToken), cloneNode(node.scriptTag), cloneNodeList(node.directives), @@ -280,7 +281,7 @@ class AstCloner implements AstVisitor { @override ConditionalExpression visitConditionalExpression( ConditionalExpression node) => - new ConditionalExpression( + astFactory.conditionalExpression( cloneNode(node.condition), cloneToken(node.question), cloneNode(node.thenExpression), @@ -288,19 +289,20 @@ class AstCloner implements AstVisitor { cloneNode(node.elseExpression)); @override - Configuration visitConfiguration(Configuration node) => new Configuration( - cloneToken(node.ifKeyword), - cloneToken(node.leftParenthesis), - cloneNode(node.name), - cloneToken(node.equalToken), - cloneNode(node.value), - cloneToken(node.rightParenthesis), - cloneNode(node.uri)); + Configuration visitConfiguration(Configuration node) => + astFactory.configuration( + cloneToken(node.ifKeyword), + cloneToken(node.leftParenthesis), + cloneNode(node.name), + cloneToken(node.equalToken), + cloneNode(node.value), + cloneToken(node.rightParenthesis), + cloneNode(node.uri)); @override ConstructorDeclaration visitConstructorDeclaration( ConstructorDeclaration node) => - new ConstructorDeclaration( + astFactory.constructorDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.externalKeyword), @@ -318,7 +320,7 @@ class AstCloner implements AstVisitor { @override ConstructorFieldInitializer visitConstructorFieldInitializer( ConstructorFieldInitializer node) => - new ConstructorFieldInitializer( + astFactory.constructorFieldInitializer( cloneToken(node.thisKeyword), cloneToken(node.period), cloneNode(node.fieldName), @@ -327,17 +329,17 @@ class AstCloner implements AstVisitor { @override ConstructorName visitConstructorName(ConstructorName node) => - new ConstructorName( + astFactory.constructorName( cloneNode(node.type), cloneToken(node.period), cloneNode(node.name)); @override ContinueStatement visitContinueStatement(ContinueStatement node) => - new ContinueStatement(cloneToken(node.continueKeyword), + astFactory.continueStatement(cloneToken(node.continueKeyword), cloneNode(node.label), cloneToken(node.semicolon)); @override DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => - new DeclaredIdentifier( + astFactory.declaredIdentifier( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -347,11 +349,11 @@ class AstCloner implements AstVisitor { @override DefaultFormalParameter visitDefaultFormalParameter( DefaultFormalParameter node) => - new DefaultFormalParameter(cloneNode(node.parameter), node.kind, + astFactory.defaultFormalParameter(cloneNode(node.parameter), node.kind, cloneToken(node.separator), cloneNode(node.defaultValue)); @override - DoStatement visitDoStatement(DoStatement node) => new DoStatement( + DoStatement visitDoStatement(DoStatement node) => astFactory.doStatement( cloneToken(node.doKeyword), cloneNode(node.body), cloneToken(node.whileKeyword), @@ -362,28 +364,28 @@ class AstCloner implements AstVisitor { @override DottedName visitDottedName(DottedName node) => - new DottedName(cloneNodeList(node.components)); + astFactory.dottedName(cloneNodeList(node.components)); @override DoubleLiteral visitDoubleLiteral(DoubleLiteral node) => - new DoubleLiteral(cloneToken(node.literal), node.value); + astFactory.doubleLiteral(cloneToken(node.literal), node.value); @override EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => - new EmptyFunctionBody(cloneToken(node.semicolon)); + astFactory.emptyFunctionBody(cloneToken(node.semicolon)); @override EmptyStatement visitEmptyStatement(EmptyStatement node) => - new EmptyStatement(cloneToken(node.semicolon)); + astFactory.emptyStatement(cloneToken(node.semicolon)); @override AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) => - new EnumConstantDeclaration(cloneNode(node.documentationComment), + astFactory.enumConstantDeclaration(cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneNode(node.name)); @override EnumDeclaration visitEnumDeclaration(EnumDeclaration node) => - new EnumDeclaration( + astFactory.enumDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.enumKeyword), @@ -394,7 +396,7 @@ class AstCloner implements AstVisitor { @override ExportDirective visitExportDirective(ExportDirective node) { - ExportDirectiveImpl directive = new ExportDirective( + ExportDirectiveImpl directive = astFactory.exportDirective( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -412,7 +414,7 @@ class AstCloner implements AstVisitor { @override ExpressionFunctionBody visitExpressionFunctionBody( ExpressionFunctionBody node) => - new ExpressionFunctionBody( + astFactory.expressionFunctionBody( cloneToken(node.keyword), cloneToken(node.functionDefinition), cloneNode(node.expression), @@ -420,16 +422,17 @@ class AstCloner implements AstVisitor { @override ExpressionStatement visitExpressionStatement(ExpressionStatement node) => - new ExpressionStatement( + astFactory.expressionStatement( cloneNode(node.expression), cloneToken(node.semicolon)); @override - ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause( - cloneToken(node.extendsKeyword), cloneNode(node.superclass)); + ExtendsClause visitExtendsClause(ExtendsClause node) => + astFactory.extendsClause( + cloneToken(node.extendsKeyword), cloneNode(node.superclass)); @override FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => - new FieldDeclaration( + astFactory.fieldDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.staticKeyword), @@ -438,7 +441,7 @@ class AstCloner implements AstVisitor { @override FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => - new FieldFormalParameter( + astFactory.fieldFormalParameter( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -453,7 +456,7 @@ class AstCloner implements AstVisitor { ForEachStatement visitForEachStatement(ForEachStatement node) { DeclaredIdentifier loopVariable = node.loopVariable; if (loopVariable == null) { - return new ForEachStatement.withReference( + return astFactory.forEachStatementWithReference( cloneToken(node.awaitKeyword), cloneToken(node.forKeyword), cloneToken(node.leftParenthesis), @@ -463,7 +466,7 @@ class AstCloner implements AstVisitor { cloneToken(node.rightParenthesis), cloneNode(node.body)); } - return new ForEachStatement.withDeclaration( + return astFactory.forEachStatementWithDeclaration( cloneToken(node.awaitKeyword), cloneToken(node.forKeyword), cloneToken(node.leftParenthesis), @@ -476,7 +479,7 @@ class AstCloner implements AstVisitor { @override FormalParameterList visitFormalParameterList(FormalParameterList node) => - new FormalParameterList( + astFactory.formalParameterList( cloneToken(node.leftParenthesis), cloneNodeList(node.parameters), cloneToken(node.leftDelimiter), @@ -484,7 +487,7 @@ class AstCloner implements AstVisitor { cloneToken(node.rightParenthesis)); @override - ForStatement visitForStatement(ForStatement node) => new ForStatement( + ForStatement visitForStatement(ForStatement node) => astFactory.forStatement( cloneToken(node.forKeyword), cloneToken(node.leftParenthesis), cloneNode(node.variables), @@ -498,7 +501,7 @@ class AstCloner implements AstVisitor { @override FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => - new FunctionDeclaration( + astFactory.functionDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.externalKeyword), @@ -510,22 +513,23 @@ class AstCloner implements AstVisitor { @override FunctionDeclarationStatement visitFunctionDeclarationStatement( FunctionDeclarationStatement node) => - new FunctionDeclarationStatement(cloneNode(node.functionDeclaration)); + astFactory + .functionDeclarationStatement(cloneNode(node.functionDeclaration)); @override FunctionExpression visitFunctionExpression(FunctionExpression node) => - new FunctionExpression(cloneNode(node.typeParameters), + astFactory.functionExpression(cloneNode(node.typeParameters), cloneNode(node.parameters), cloneNode(node.body)); @override FunctionExpressionInvocation visitFunctionExpressionInvocation( FunctionExpressionInvocation node) => - new FunctionExpressionInvocation(cloneNode(node.function), + astFactory.functionExpressionInvocation(cloneNode(node.function), cloneNode(node.typeArguments), cloneNode(node.argumentList)); @override FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => - new FunctionTypeAlias( + astFactory.functionTypeAlias( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.typedefKeyword), @@ -538,7 +542,7 @@ class AstCloner implements AstVisitor { @override FunctionTypedFormalParameter visitFunctionTypedFormalParameter( FunctionTypedFormalParameter node) => - new FunctionTypedFormalParameter( + astFactory.functionTypedFormalParameter( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneNode(node.returnType), @@ -547,11 +551,12 @@ class AstCloner implements AstVisitor { cloneNode(node.parameters)); @override - HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator( - cloneToken(node.keyword), cloneNodeList(node.hiddenNames)); + HideCombinator visitHideCombinator(HideCombinator node) => + astFactory.hideCombinator( + cloneToken(node.keyword), cloneNodeList(node.hiddenNames)); @override - IfStatement visitIfStatement(IfStatement node) => new IfStatement( + IfStatement visitIfStatement(IfStatement node) => astFactory.ifStatement( cloneToken(node.ifKeyword), cloneToken(node.leftParenthesis), cloneNode(node.condition), @@ -562,12 +567,12 @@ class AstCloner implements AstVisitor { @override ImplementsClause visitImplementsClause(ImplementsClause node) => - new ImplementsClause( + astFactory.implementsClause( cloneToken(node.implementsKeyword), cloneNodeList(node.interfaces)); @override ImportDirective visitImportDirective(ImportDirective node) { - ImportDirectiveImpl directive = new ImportDirective( + ImportDirectiveImpl directive = astFactory.importDirective( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -589,13 +594,13 @@ class AstCloner implements AstVisitor { IndexExpression visitIndexExpression(IndexExpression node) { Token period = node.period; if (period == null) { - return new IndexExpression.forTarget( + return astFactory.indexExpressionForTarget( cloneNode(node.target), cloneToken(node.leftBracket), cloneNode(node.index), cloneToken(node.rightBracket)); } else { - return new IndexExpression.forCascade( + return astFactory.indexExpressionForCascade( cloneToken(period), cloneToken(node.leftBracket), cloneNode(node.index), @@ -606,25 +611,25 @@ class AstCloner implements AstVisitor { @override InstanceCreationExpression visitInstanceCreationExpression( InstanceCreationExpression node) => - new InstanceCreationExpression(cloneToken(node.keyword), + astFactory.instanceCreationExpression(cloneToken(node.keyword), cloneNode(node.constructorName), cloneNode(node.argumentList)); @override IntegerLiteral visitIntegerLiteral(IntegerLiteral node) => - new IntegerLiteral(cloneToken(node.literal), node.value); + astFactory.integerLiteral(cloneToken(node.literal), node.value); @override InterpolationExpression visitInterpolationExpression( InterpolationExpression node) => - new InterpolationExpression(cloneToken(node.leftBracket), + astFactory.interpolationExpression(cloneToken(node.leftBracket), cloneNode(node.expression), cloneToken(node.rightBracket)); @override InterpolationString visitInterpolationString(InterpolationString node) => - new InterpolationString(cloneToken(node.contents), node.value); + astFactory.interpolationString(cloneToken(node.contents), node.value); @override - IsExpression visitIsExpression(IsExpression node) => new IsExpression( + IsExpression visitIsExpression(IsExpression node) => astFactory.isExpression( cloneNode(node.expression), cloneToken(node.isOperator), cloneToken(node.notOperator), @@ -632,16 +637,15 @@ class AstCloner implements AstVisitor { @override Label visitLabel(Label node) => - new Label(cloneNode(node.label), cloneToken(node.colon)); + astFactory.label(cloneNode(node.label), cloneToken(node.colon)); @override - LabeledStatement visitLabeledStatement(LabeledStatement node) => - new LabeledStatement( - cloneNodeList(node.labels), cloneNode(node.statement)); + LabeledStatement visitLabeledStatement(LabeledStatement node) => astFactory + .labeledStatement(cloneNodeList(node.labels), cloneNode(node.statement)); @override LibraryDirective visitLibraryDirective(LibraryDirective node) => - new LibraryDirective( + astFactory.libraryDirective( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.libraryKeyword), @@ -650,10 +654,10 @@ class AstCloner implements AstVisitor { @override LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) => - new LibraryIdentifier(cloneNodeList(node.components)); + astFactory.libraryIdentifier(cloneNodeList(node.components)); @override - ListLiteral visitListLiteral(ListLiteral node) => new ListLiteral( + ListLiteral visitListLiteral(ListLiteral node) => astFactory.listLiteral( cloneToken(node.constKeyword), cloneNode(node.typeArguments), cloneToken(node.leftBracket), @@ -661,7 +665,7 @@ class AstCloner implements AstVisitor { cloneToken(node.rightBracket)); @override - MapLiteral visitMapLiteral(MapLiteral node) => new MapLiteral( + MapLiteral visitMapLiteral(MapLiteral node) => astFactory.mapLiteral( cloneToken(node.constKeyword), cloneNode(node.typeArguments), cloneToken(node.leftBracket), @@ -670,12 +674,12 @@ class AstCloner implements AstVisitor { @override MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => - new MapLiteralEntry(cloneNode(node.key), cloneToken(node.separator), - cloneNode(node.value)); + astFactory.mapLiteralEntry(cloneNode(node.key), + cloneToken(node.separator), cloneNode(node.value)); @override MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => - new MethodDeclaration( + astFactory.methodDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.externalKeyword), @@ -690,7 +694,7 @@ class AstCloner implements AstVisitor { @override MethodInvocation visitMethodInvocation(MethodInvocation node) => - new MethodInvocation( + astFactory.methodInvocation( cloneNode(node.target), cloneToken(node.operator), cloneNode(node.methodName), @@ -698,31 +702,31 @@ class AstCloner implements AstVisitor { cloneNode(node.argumentList)); @override - NamedExpression visitNamedExpression(NamedExpression node) => - new NamedExpression(cloneNode(node.name), cloneNode(node.expression)); + NamedExpression visitNamedExpression(NamedExpression node) => astFactory + .namedExpression(cloneNode(node.name), cloneNode(node.expression)); @override - AstNode visitNativeClause(NativeClause node) => - new NativeClause(cloneToken(node.nativeKeyword), cloneNode(node.name)); + AstNode visitNativeClause(NativeClause node) => astFactory.nativeClause( + cloneToken(node.nativeKeyword), cloneNode(node.name)); @override NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => - new NativeFunctionBody(cloneToken(node.nativeKeyword), + astFactory.nativeFunctionBody(cloneToken(node.nativeKeyword), cloneNode(node.stringLiteral), cloneToken(node.semicolon)); @override NullLiteral visitNullLiteral(NullLiteral node) => - new NullLiteral(cloneToken(node.literal)); + astFactory.nullLiteral(cloneToken(node.literal)); @override ParenthesizedExpression visitParenthesizedExpression( ParenthesizedExpression node) => - new ParenthesizedExpression(cloneToken(node.leftParenthesis), + astFactory.parenthesizedExpression(cloneToken(node.leftParenthesis), cloneNode(node.expression), cloneToken(node.rightParenthesis)); @override PartDirective visitPartDirective(PartDirective node) { - PartDirective directive = new PartDirective( + PartDirective directive = astFactory.partDirective( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.partKeyword), @@ -735,7 +739,7 @@ class AstCloner implements AstVisitor { @override PartOfDirective visitPartOfDirective(PartOfDirective node) => - new PartOfDirective( + astFactory.partOfDirective( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.partKeyword), @@ -745,28 +749,27 @@ class AstCloner implements AstVisitor { cloneToken(node.semicolon)); @override - PostfixExpression visitPostfixExpression(PostfixExpression node) => - new PostfixExpression(cloneNode(node.operand), cloneToken(node.operator)); + PostfixExpression visitPostfixExpression(PostfixExpression node) => astFactory + .postfixExpression(cloneNode(node.operand), cloneToken(node.operator)); @override PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) => - new PrefixedIdentifier(cloneNode(node.prefix), cloneToken(node.period), - cloneNode(node.identifier)); + astFactory.prefixedIdentifier(cloneNode(node.prefix), + cloneToken(node.period), cloneNode(node.identifier)); @override - PrefixExpression visitPrefixExpression(PrefixExpression node) => - new PrefixExpression(cloneToken(node.operator), cloneNode(node.operand)); + PrefixExpression visitPrefixExpression(PrefixExpression node) => astFactory + .prefixExpression(cloneToken(node.operator), cloneNode(node.operand)); @override - PropertyAccess visitPropertyAccess(PropertyAccess node) => new PropertyAccess( - cloneNode(node.target), - cloneToken(node.operator), - cloneNode(node.propertyName)); + PropertyAccess visitPropertyAccess(PropertyAccess node) => + astFactory.propertyAccess(cloneNode(node.target), + cloneToken(node.operator), cloneNode(node.propertyName)); @override RedirectingConstructorInvocation visitRedirectingConstructorInvocation( RedirectingConstructorInvocation node) => - new RedirectingConstructorInvocation( + astFactory.redirectingConstructorInvocation( cloneToken(node.thisKeyword), cloneToken(node.period), cloneNode(node.constructorName), @@ -774,25 +777,25 @@ class AstCloner implements AstVisitor { @override RethrowExpression visitRethrowExpression(RethrowExpression node) => - new RethrowExpression(cloneToken(node.rethrowKeyword)); + astFactory.rethrowExpression(cloneToken(node.rethrowKeyword)); @override ReturnStatement visitReturnStatement(ReturnStatement node) => - new ReturnStatement(cloneToken(node.returnKeyword), + astFactory.returnStatement(cloneToken(node.returnKeyword), cloneNode(node.expression), cloneToken(node.semicolon)); @override ScriptTag visitScriptTag(ScriptTag node) => - new ScriptTag(cloneToken(node.scriptTag)); + astFactory.scriptTag(cloneToken(node.scriptTag)); @override - ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator( - cloneToken(node.keyword), cloneNodeList(node.shownNames)); + ShowCombinator visitShowCombinator(ShowCombinator node) => astFactory + .showCombinator(cloneToken(node.keyword), cloneNodeList(node.shownNames)); @override SimpleFormalParameter visitSimpleFormalParameter( SimpleFormalParameter node) => - new SimpleFormalParameter( + astFactory.simpleFormalParameter( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -801,21 +804,21 @@ class AstCloner implements AstVisitor { @override SimpleIdentifier visitSimpleIdentifier(SimpleIdentifier node) => - new SimpleIdentifier(cloneToken(node.token), + astFactory.simpleIdentifier(cloneToken(node.token), isDeclaration: node.inDeclarationContext()); @override SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) => - new SimpleStringLiteral(cloneToken(node.literal), node.value); + astFactory.simpleStringLiteral(cloneToken(node.literal), node.value); @override StringInterpolation visitStringInterpolation(StringInterpolation node) => - new StringInterpolation(cloneNodeList(node.elements)); + astFactory.stringInterpolation(cloneNodeList(node.elements)); @override SuperConstructorInvocation visitSuperConstructorInvocation( SuperConstructorInvocation node) => - new SuperConstructorInvocation( + astFactory.superConstructorInvocation( cloneToken(node.superKeyword), cloneToken(node.period), cloneNode(node.constructorName), @@ -823,10 +826,10 @@ class AstCloner implements AstVisitor { @override SuperExpression visitSuperExpression(SuperExpression node) => - new SuperExpression(cloneToken(node.superKeyword)); + astFactory.superExpression(cloneToken(node.superKeyword)); @override - SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase( + SwitchCase visitSwitchCase(SwitchCase node) => astFactory.switchCase( cloneNodeList(node.labels), cloneToken(node.keyword), cloneNode(node.expression), @@ -834,15 +837,16 @@ class AstCloner implements AstVisitor { cloneNodeList(node.statements)); @override - SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault( - cloneNodeList(node.labels), - cloneToken(node.keyword), - cloneToken(node.colon), - cloneNodeList(node.statements)); + SwitchDefault visitSwitchDefault(SwitchDefault node) => + astFactory.switchDefault( + cloneNodeList(node.labels), + cloneToken(node.keyword), + cloneToken(node.colon), + cloneNodeList(node.statements)); @override SwitchStatement visitSwitchStatement(SwitchStatement node) => - new SwitchStatement( + astFactory.switchStatement( cloneToken(node.switchKeyword), cloneToken(node.leftParenthesis), cloneNode(node.expression), @@ -852,29 +856,30 @@ class AstCloner implements AstVisitor { cloneToken(node.rightBracket)); @override - SymbolLiteral visitSymbolLiteral(SymbolLiteral node) => new SymbolLiteral( - cloneToken(node.poundSign), cloneTokenList(node.components)); + SymbolLiteral visitSymbolLiteral(SymbolLiteral node) => + astFactory.symbolLiteral( + cloneToken(node.poundSign), cloneTokenList(node.components)); @override ThisExpression visitThisExpression(ThisExpression node) => - new ThisExpression(cloneToken(node.thisKeyword)); + astFactory.thisExpression(cloneToken(node.thisKeyword)); @override ThrowExpression visitThrowExpression(ThrowExpression node) => - new ThrowExpression( + astFactory.throwExpression( cloneToken(node.throwKeyword), cloneNode(node.expression)); @override TopLevelVariableDeclaration visitTopLevelVariableDeclaration( TopLevelVariableDeclaration node) => - new TopLevelVariableDeclaration( + astFactory.topLevelVariableDeclaration( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneNode(node.variables), cloneToken(node.semicolon)); @override - TryStatement visitTryStatement(TryStatement node) => new TryStatement( + TryStatement visitTryStatement(TryStatement node) => astFactory.tryStatement( cloneToken(node.tryKeyword), cloneNode(node.body), cloneNodeList(node.catchClauses), @@ -883,35 +888,36 @@ class AstCloner implements AstVisitor { @override TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => - new TypeArgumentList(cloneToken(node.leftBracket), + astFactory.typeArgumentList(cloneToken(node.leftBracket), cloneNodeList(node.arguments), cloneToken(node.rightBracket)); @override TypeName visitTypeName(TypeName node) => - new TypeName(cloneNode(node.name), cloneNode(node.typeArguments)); + astFactory.typeName(cloneNode(node.name), cloneNode(node.typeArguments)); @override - TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter( - cloneNode(node.documentationComment), - cloneNodeList(node.metadata), - cloneNode(node.name), - cloneToken(node.extendsKeyword), - cloneNode(node.bound)); + TypeParameter visitTypeParameter(TypeParameter node) => + astFactory.typeParameter( + cloneNode(node.documentationComment), + cloneNodeList(node.metadata), + cloneNode(node.name), + cloneToken(node.extendsKeyword), + cloneNode(node.bound)); @override TypeParameterList visitTypeParameterList(TypeParameterList node) => - new TypeParameterList(cloneToken(node.leftBracket), + astFactory.typeParameterList(cloneToken(node.leftBracket), cloneNodeList(node.typeParameters), cloneToken(node.rightBracket)); @override VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => - new VariableDeclaration(cloneNode(node.name), cloneToken(node.equals), - cloneNode(node.initializer)); + astFactory.variableDeclaration(cloneNode(node.name), + cloneToken(node.equals), cloneNode(node.initializer)); @override VariableDeclarationList visitVariableDeclarationList( VariableDeclarationList node) => - new VariableDeclarationList( + astFactory.variableDeclarationList( cloneNode(node.documentationComment), cloneNodeList(node.metadata), cloneToken(node.keyword), @@ -921,27 +927,29 @@ class AstCloner implements AstVisitor { @override VariableDeclarationStatement visitVariableDeclarationStatement( VariableDeclarationStatement node) => - new VariableDeclarationStatement( + astFactory.variableDeclarationStatement( cloneNode(node.variables), cloneToken(node.semicolon)); @override - WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement( - cloneToken(node.whileKeyword), - cloneToken(node.leftParenthesis), - cloneNode(node.condition), - cloneToken(node.rightParenthesis), - cloneNode(node.body)); + WhileStatement visitWhileStatement(WhileStatement node) => + astFactory.whileStatement( + cloneToken(node.whileKeyword), + cloneToken(node.leftParenthesis), + cloneNode(node.condition), + cloneToken(node.rightParenthesis), + cloneNode(node.body)); @override - WithClause visitWithClause(WithClause node) => new WithClause( + WithClause visitWithClause(WithClause node) => astFactory.withClause( cloneToken(node.withKeyword), cloneNodeList(node.mixinTypes)); @override - YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement( - cloneToken(node.yieldKeyword), - cloneToken(node.star), - cloneNode(node.expression), - cloneToken(node.semicolon)); + YieldStatement visitYieldStatement(YieldStatement node) => + astFactory.yieldStatement( + cloneToken(node.yieldKeyword), + cloneToken(node.star), + cloneNode(node.expression), + cloneToken(node.semicolon)); /** * Clone all token starting from the given [token] up to a token that has @@ -2755,11 +2763,11 @@ class IncrementalAstCloner implements AstVisitor { @override AdjacentStrings visitAdjacentStrings(AdjacentStrings node) => - new AdjacentStrings(_cloneNodeList(node.strings)); + astFactory.adjacentStrings(_cloneNodeList(node.strings)); @override Annotation visitAnnotation(Annotation node) { - Annotation copy = new Annotation( + Annotation copy = astFactory.annotation( _mapToken(node.atSign), _cloneNode(node.name), _mapToken(node.period), @@ -2770,14 +2778,14 @@ class IncrementalAstCloner implements AstVisitor { } @override - ArgumentList visitArgumentList(ArgumentList node) => new ArgumentList( + ArgumentList visitArgumentList(ArgumentList node) => astFactory.argumentList( _mapToken(node.leftParenthesis), _cloneNodeList(node.arguments), _mapToken(node.rightParenthesis)); @override AsExpression visitAsExpression(AsExpression node) { - AsExpression copy = new AsExpression(_cloneNode(node.expression), + AsExpression copy = astFactory.asExpression(_cloneNode(node.expression), _mapToken(node.asOperator), _cloneNode(node.type)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; @@ -2786,7 +2794,7 @@ class IncrementalAstCloner implements AstVisitor { @override AstNode visitAssertInitializer(AssertInitializer node) => - new AssertInitializer( + astFactory.assertInitializer( _mapToken(node.assertKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), @@ -2795,18 +2803,19 @@ class IncrementalAstCloner implements AstVisitor { _mapToken(node.rightParenthesis)); @override - AstNode visitAssertStatement(AssertStatement node) => new AssertStatement( - _mapToken(node.assertKeyword), - _mapToken(node.leftParenthesis), - _cloneNode(node.condition), - _mapToken(node.comma), - _cloneNode(node.message), - _mapToken(node.rightParenthesis), - _mapToken(node.semicolon)); + AstNode visitAssertStatement(AssertStatement node) => + astFactory.assertStatement( + _mapToken(node.assertKeyword), + _mapToken(node.leftParenthesis), + _cloneNode(node.condition), + _mapToken(node.comma), + _cloneNode(node.message), + _mapToken(node.rightParenthesis), + _mapToken(node.semicolon)); @override AssignmentExpression visitAssignmentExpression(AssignmentExpression node) { - AssignmentExpression copy = new AssignmentExpression( + AssignmentExpression copy = astFactory.assignmentExpression( _cloneNode(node.leftHandSide), _mapToken(node.operator), _cloneNode(node.rightHandSide)); @@ -2819,13 +2828,15 @@ class IncrementalAstCloner implements AstVisitor { @override AwaitExpression visitAwaitExpression(AwaitExpression node) => - new AwaitExpression( + astFactory.awaitExpression( _mapToken(node.awaitKeyword), _cloneNode(node.expression)); @override BinaryExpression visitBinaryExpression(BinaryExpression node) { - BinaryExpression copy = new BinaryExpression(_cloneNode(node.leftOperand), - _mapToken(node.operator), _cloneNode(node.rightOperand)); + BinaryExpression copy = astFactory.binaryExpression( + _cloneNode(node.leftOperand), + _mapToken(node.operator), + _cloneNode(node.rightOperand)); copy.propagatedElement = node.propagatedElement; copy.propagatedType = node.propagatedType; copy.staticElement = node.staticElement; @@ -2834,32 +2845,31 @@ class IncrementalAstCloner implements AstVisitor { } @override - Block visitBlock(Block node) => new Block(_mapToken(node.leftBracket), + Block visitBlock(Block node) => astFactory.block(_mapToken(node.leftBracket), _cloneNodeList(node.statements), _mapToken(node.rightBracket)); @override BlockFunctionBody visitBlockFunctionBody(BlockFunctionBody node) => - new BlockFunctionBody(_mapToken(node.keyword), _mapToken(node.star), - _cloneNode(node.block)); + astFactory.blockFunctionBody(_mapToken(node.keyword), + _mapToken(node.star), _cloneNode(node.block)); @override BooleanLiteral visitBooleanLiteral(BooleanLiteral node) { BooleanLiteral copy = - new BooleanLiteral(_mapToken(node.literal), node.value); + astFactory.booleanLiteral(_mapToken(node.literal), node.value); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; } @override - BreakStatement visitBreakStatement(BreakStatement node) => new BreakStatement( - _mapToken(node.breakKeyword), - _cloneNode(node.label), - _mapToken(node.semicolon)); + BreakStatement visitBreakStatement(BreakStatement node) => + astFactory.breakStatement(_mapToken(node.breakKeyword), + _cloneNode(node.label), _mapToken(node.semicolon)); @override CascadeExpression visitCascadeExpression(CascadeExpression node) { - CascadeExpression copy = new CascadeExpression( + CascadeExpression copy = astFactory.cascadeExpression( _cloneNode(node.target), _cloneNodeList(node.cascadeSections)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; @@ -2867,7 +2877,7 @@ class IncrementalAstCloner implements AstVisitor { } @override - CatchClause visitCatchClause(CatchClause node) => new CatchClause( + CatchClause visitCatchClause(CatchClause node) => astFactory.catchClause( _mapToken(node.onKeyword), _cloneNode(node.exceptionType), _mapToken(node.catchKeyword), @@ -2880,7 +2890,7 @@ class IncrementalAstCloner implements AstVisitor { @override ClassDeclaration visitClassDeclaration(ClassDeclaration node) { - ClassDeclaration copy = new ClassDeclaration( + ClassDeclaration copy = astFactory.classDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.abstractKeyword), @@ -2898,38 +2908,39 @@ class IncrementalAstCloner implements AstVisitor { } @override - ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => new ClassTypeAlias( - _cloneNode(node.documentationComment), - _cloneNodeList(node.metadata), - _mapToken(node.typedefKeyword), - _cloneNode(node.name), - _cloneNode(node.typeParameters), - _mapToken(node.equals), - _mapToken(node.abstractKeyword), - _cloneNode(node.superclass), - _cloneNode(node.withClause), - _cloneNode(node.implementsClause), - _mapToken(node.semicolon)); + ClassTypeAlias visitClassTypeAlias(ClassTypeAlias node) => + astFactory.classTypeAlias( + _cloneNode(node.documentationComment), + _cloneNodeList(node.metadata), + _mapToken(node.typedefKeyword), + _cloneNode(node.name), + _cloneNode(node.typeParameters), + _mapToken(node.equals), + _mapToken(node.abstractKeyword), + _cloneNode(node.superclass), + _cloneNode(node.withClause), + _cloneNode(node.implementsClause), + _mapToken(node.semicolon)); @override Comment visitComment(Comment node) { if (node.isDocumentation) { - return Comment.createDocumentationCommentWithReferences( + return astFactory.documentationComment( _mapTokens(node.tokens), _cloneNodeList(node.references)); } else if (node.isBlock) { - return Comment.createBlockComment(_mapTokens(node.tokens)); + return astFactory.blockComment(_mapTokens(node.tokens)); } - return Comment.createEndOfLineComment(_mapTokens(node.tokens)); + return astFactory.endOfLineComment(_mapTokens(node.tokens)); } @override CommentReference visitCommentReference(CommentReference node) => - new CommentReference( + astFactory.commentReference( _mapToken(node.newKeyword), _cloneNode(node.identifier)); @override CompilationUnit visitCompilationUnit(CompilationUnit node) { - CompilationUnit copy = new CompilationUnit( + CompilationUnit copy = astFactory.compilationUnit( _mapToken(node.beginToken), _cloneNode(node.scriptTag), _cloneNodeList(node.directives), @@ -2942,7 +2953,7 @@ class IncrementalAstCloner implements AstVisitor { @override ConditionalExpression visitConditionalExpression(ConditionalExpression node) { - ConditionalExpression copy = new ConditionalExpression( + ConditionalExpression copy = astFactory.conditionalExpression( _cloneNode(node.condition), _mapToken(node.question), _cloneNode(node.thenExpression), @@ -2954,19 +2965,20 @@ class IncrementalAstCloner implements AstVisitor { } @override - Configuration visitConfiguration(Configuration node) => new Configuration( - _mapToken(node.ifKeyword), - _mapToken(node.leftParenthesis), - _cloneNode(node.name), - _mapToken(node.equalToken), - _cloneNode(node.value), - _mapToken(node.rightParenthesis), - _cloneNode(node.uri)); + Configuration visitConfiguration(Configuration node) => + astFactory.configuration( + _mapToken(node.ifKeyword), + _mapToken(node.leftParenthesis), + _cloneNode(node.name), + _mapToken(node.equalToken), + _cloneNode(node.value), + _mapToken(node.rightParenthesis), + _cloneNode(node.uri)); @override ConstructorDeclaration visitConstructorDeclaration( ConstructorDeclaration node) { - ConstructorDeclaration copy = new ConstructorDeclaration( + ConstructorDeclaration copy = astFactory.constructorDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), @@ -2987,7 +2999,7 @@ class IncrementalAstCloner implements AstVisitor { @override ConstructorFieldInitializer visitConstructorFieldInitializer( ConstructorFieldInitializer node) => - new ConstructorFieldInitializer( + astFactory.constructorFieldInitializer( _mapToken(node.thisKeyword), _mapToken(node.period), _cloneNode(node.fieldName), @@ -2996,7 +3008,7 @@ class IncrementalAstCloner implements AstVisitor { @override ConstructorName visitConstructorName(ConstructorName node) { - ConstructorName copy = new ConstructorName( + ConstructorName copy = astFactory.constructorName( _cloneNode(node.type), _mapToken(node.period), _cloneNode(node.name)); copy.staticElement = node.staticElement; return copy; @@ -3004,12 +3016,12 @@ class IncrementalAstCloner implements AstVisitor { @override ContinueStatement visitContinueStatement(ContinueStatement node) => - new ContinueStatement(_mapToken(node.continueKeyword), + astFactory.continueStatement(_mapToken(node.continueKeyword), _cloneNode(node.label), _mapToken(node.semicolon)); @override DeclaredIdentifier visitDeclaredIdentifier(DeclaredIdentifier node) => - new DeclaredIdentifier( + astFactory.declaredIdentifier( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3019,11 +3031,11 @@ class IncrementalAstCloner implements AstVisitor { @override DefaultFormalParameter visitDefaultFormalParameter( DefaultFormalParameter node) => - new DefaultFormalParameter(_cloneNode(node.parameter), node.kind, + astFactory.defaultFormalParameter(_cloneNode(node.parameter), node.kind, _mapToken(node.separator), _cloneNode(node.defaultValue)); @override - DoStatement visitDoStatement(DoStatement node) => new DoStatement( + DoStatement visitDoStatement(DoStatement node) => astFactory.doStatement( _mapToken(node.doKeyword), _cloneNode(node.body), _mapToken(node.whileKeyword), @@ -3034,11 +3046,12 @@ class IncrementalAstCloner implements AstVisitor { @override DottedName visitDottedName(DottedName node) => - new DottedName(_cloneNodeList(node.components)); + astFactory.dottedName(_cloneNodeList(node.components)); @override DoubleLiteral visitDoubleLiteral(DoubleLiteral node) { - DoubleLiteral copy = new DoubleLiteral(_mapToken(node.literal), node.value); + DoubleLiteral copy = + astFactory.doubleLiteral(_mapToken(node.literal), node.value); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3046,30 +3059,31 @@ class IncrementalAstCloner implements AstVisitor { @override EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) => - new EmptyFunctionBody(_mapToken(node.semicolon)); + astFactory.emptyFunctionBody(_mapToken(node.semicolon)); @override EmptyStatement visitEmptyStatement(EmptyStatement node) => - new EmptyStatement(_mapToken(node.semicolon)); + astFactory.emptyStatement(_mapToken(node.semicolon)); @override AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) => - new EnumConstantDeclaration(_cloneNode(node.documentationComment), + astFactory.enumConstantDeclaration(_cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.name)); @override - AstNode visitEnumDeclaration(EnumDeclaration node) => new EnumDeclaration( - _cloneNode(node.documentationComment), - _cloneNodeList(node.metadata), - _mapToken(node.enumKeyword), - _cloneNode(node.name), - _mapToken(node.leftBracket), - _cloneNodeList(node.constants), - _mapToken(node.rightBracket)); + AstNode visitEnumDeclaration(EnumDeclaration node) => + astFactory.enumDeclaration( + _cloneNode(node.documentationComment), + _cloneNodeList(node.metadata), + _mapToken(node.enumKeyword), + _cloneNode(node.name), + _mapToken(node.leftBracket), + _cloneNodeList(node.constants), + _mapToken(node.rightBracket)); @override ExportDirective visitExportDirective(ExportDirective node) { - ExportDirective copy = new ExportDirective( + ExportDirective copy = astFactory.exportDirective( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3084,7 +3098,7 @@ class IncrementalAstCloner implements AstVisitor { @override ExpressionFunctionBody visitExpressionFunctionBody( ExpressionFunctionBody node) => - new ExpressionFunctionBody( + astFactory.expressionFunctionBody( _mapToken(node.keyword), _mapToken(node.functionDefinition), _cloneNode(node.expression), @@ -3092,16 +3106,17 @@ class IncrementalAstCloner implements AstVisitor { @override ExpressionStatement visitExpressionStatement(ExpressionStatement node) => - new ExpressionStatement( + astFactory.expressionStatement( _cloneNode(node.expression), _mapToken(node.semicolon)); @override - ExtendsClause visitExtendsClause(ExtendsClause node) => new ExtendsClause( - _mapToken(node.extendsKeyword), _cloneNode(node.superclass)); + ExtendsClause visitExtendsClause(ExtendsClause node) => + astFactory.extendsClause( + _mapToken(node.extendsKeyword), _cloneNode(node.superclass)); @override FieldDeclaration visitFieldDeclaration(FieldDeclaration node) => - new FieldDeclaration( + astFactory.fieldDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.staticKeyword), @@ -3110,7 +3125,7 @@ class IncrementalAstCloner implements AstVisitor { @override FieldFormalParameter visitFieldFormalParameter(FieldFormalParameter node) => - new FieldFormalParameter( + astFactory.fieldFormalParameter( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3125,7 +3140,7 @@ class IncrementalAstCloner implements AstVisitor { ForEachStatement visitForEachStatement(ForEachStatement node) { DeclaredIdentifier loopVariable = node.loopVariable; if (loopVariable == null) { - return new ForEachStatement.withReference( + return astFactory.forEachStatementWithReference( _mapToken(node.awaitKeyword), _mapToken(node.forKeyword), _mapToken(node.leftParenthesis), @@ -3135,7 +3150,7 @@ class IncrementalAstCloner implements AstVisitor { _mapToken(node.rightParenthesis), _cloneNode(node.body)); } - return new ForEachStatement.withDeclaration( + return astFactory.forEachStatementWithDeclaration( _mapToken(node.awaitKeyword), _mapToken(node.forKeyword), _mapToken(node.leftParenthesis), @@ -3148,7 +3163,7 @@ class IncrementalAstCloner implements AstVisitor { @override FormalParameterList visitFormalParameterList(FormalParameterList node) => - new FormalParameterList( + astFactory.formalParameterList( _mapToken(node.leftParenthesis), _cloneNodeList(node.parameters), _mapToken(node.leftDelimiter), @@ -3156,7 +3171,7 @@ class IncrementalAstCloner implements AstVisitor { _mapToken(node.rightParenthesis)); @override - ForStatement visitForStatement(ForStatement node) => new ForStatement( + ForStatement visitForStatement(ForStatement node) => astFactory.forStatement( _mapToken(node.forKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.variables), @@ -3170,7 +3185,7 @@ class IncrementalAstCloner implements AstVisitor { @override FunctionDeclaration visitFunctionDeclaration(FunctionDeclaration node) => - new FunctionDeclaration( + astFactory.functionDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), @@ -3182,11 +3197,12 @@ class IncrementalAstCloner implements AstVisitor { @override FunctionDeclarationStatement visitFunctionDeclarationStatement( FunctionDeclarationStatement node) => - new FunctionDeclarationStatement(_cloneNode(node.functionDeclaration)); + astFactory + .functionDeclarationStatement(_cloneNode(node.functionDeclaration)); @override FunctionExpression visitFunctionExpression(FunctionExpression node) { - FunctionExpression copy = new FunctionExpression( + FunctionExpression copy = astFactory.functionExpression( _cloneNode(node.typeParameters), _cloneNode(node.parameters), _cloneNode(node.body)); @@ -3199,7 +3215,7 @@ class IncrementalAstCloner implements AstVisitor { @override FunctionExpressionInvocation visitFunctionExpressionInvocation( FunctionExpressionInvocation node) { - FunctionExpressionInvocation copy = new FunctionExpressionInvocation( + FunctionExpressionInvocation copy = astFactory.functionExpressionInvocation( _cloneNode(node.function), _cloneNode(node.typeArguments), _cloneNode(node.argumentList)); @@ -3212,7 +3228,7 @@ class IncrementalAstCloner implements AstVisitor { @override FunctionTypeAlias visitFunctionTypeAlias(FunctionTypeAlias node) => - new FunctionTypeAlias( + astFactory.functionTypeAlias( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.typedefKeyword), @@ -3225,7 +3241,7 @@ class IncrementalAstCloner implements AstVisitor { @override FunctionTypedFormalParameter visitFunctionTypedFormalParameter( FunctionTypedFormalParameter node) => - new FunctionTypedFormalParameter( + astFactory.functionTypedFormalParameter( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.returnType), @@ -3234,11 +3250,12 @@ class IncrementalAstCloner implements AstVisitor { _cloneNode(node.parameters)); @override - HideCombinator visitHideCombinator(HideCombinator node) => new HideCombinator( - _mapToken(node.keyword), _cloneNodeList(node.hiddenNames)); + HideCombinator visitHideCombinator(HideCombinator node) => + astFactory.hideCombinator( + _mapToken(node.keyword), _cloneNodeList(node.hiddenNames)); @override - IfStatement visitIfStatement(IfStatement node) => new IfStatement( + IfStatement visitIfStatement(IfStatement node) => astFactory.ifStatement( _mapToken(node.ifKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.condition), @@ -3249,12 +3266,12 @@ class IncrementalAstCloner implements AstVisitor { @override ImplementsClause visitImplementsClause(ImplementsClause node) => - new ImplementsClause( + astFactory.implementsClause( _mapToken(node.implementsKeyword), _cloneNodeList(node.interfaces)); @override ImportDirective visitImportDirective(ImportDirective node) { - ImportDirective copy = new ImportDirective( + ImportDirective copy = astFactory.importDirective( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3274,14 +3291,17 @@ class IncrementalAstCloner implements AstVisitor { Token period = _mapToken(node.period); IndexExpression copy; if (period == null) { - copy = new IndexExpression.forTarget( + copy = astFactory.indexExpressionForTarget( _cloneNode(node.target), _mapToken(node.leftBracket), _cloneNode(node.index), _mapToken(node.rightBracket)); } else { - copy = new IndexExpression.forCascade(period, _mapToken(node.leftBracket), - _cloneNode(node.index), _mapToken(node.rightBracket)); + copy = astFactory.indexExpressionForCascade( + period, + _mapToken(node.leftBracket), + _cloneNode(node.index), + _mapToken(node.rightBracket)); } copy.auxiliaryElements = node.auxiliaryElements; copy.propagatedElement = node.propagatedElement; @@ -3294,7 +3314,7 @@ class IncrementalAstCloner implements AstVisitor { @override InstanceCreationExpression visitInstanceCreationExpression( InstanceCreationExpression node) { - InstanceCreationExpression copy = new InstanceCreationExpression( + InstanceCreationExpression copy = astFactory.instanceCreationExpression( _mapToken(node.keyword), _cloneNode(node.constructorName), _cloneNode(node.argumentList)); @@ -3307,7 +3327,7 @@ class IncrementalAstCloner implements AstVisitor { @override IntegerLiteral visitIntegerLiteral(IntegerLiteral node) { IntegerLiteral copy = - new IntegerLiteral(_mapToken(node.literal), node.value); + astFactory.integerLiteral(_mapToken(node.literal), node.value); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3316,16 +3336,16 @@ class IncrementalAstCloner implements AstVisitor { @override InterpolationExpression visitInterpolationExpression( InterpolationExpression node) => - new InterpolationExpression(_mapToken(node.leftBracket), + astFactory.interpolationExpression(_mapToken(node.leftBracket), _cloneNode(node.expression), _mapToken(node.rightBracket)); @override InterpolationString visitInterpolationString(InterpolationString node) => - new InterpolationString(_mapToken(node.contents), node.value); + astFactory.interpolationString(_mapToken(node.contents), node.value); @override IsExpression visitIsExpression(IsExpression node) { - IsExpression copy = new IsExpression( + IsExpression copy = astFactory.isExpression( _cloneNode(node.expression), _mapToken(node.isOperator), _mapToken(node.notOperator), @@ -3337,16 +3357,16 @@ class IncrementalAstCloner implements AstVisitor { @override Label visitLabel(Label node) => - new Label(_cloneNode(node.label), _mapToken(node.colon)); + astFactory.label(_cloneNode(node.label), _mapToken(node.colon)); @override LabeledStatement visitLabeledStatement(LabeledStatement node) => - new LabeledStatement( + astFactory.labeledStatement( _cloneNodeList(node.labels), _cloneNode(node.statement)); @override LibraryDirective visitLibraryDirective(LibraryDirective node) { - LibraryDirective copy = new LibraryDirective( + LibraryDirective copy = astFactory.libraryDirective( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.libraryKeyword), @@ -3359,7 +3379,7 @@ class IncrementalAstCloner implements AstVisitor { @override LibraryIdentifier visitLibraryIdentifier(LibraryIdentifier node) { LibraryIdentifier copy = - new LibraryIdentifier(_cloneNodeList(node.components)); + astFactory.libraryIdentifier(_cloneNodeList(node.components)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3367,7 +3387,7 @@ class IncrementalAstCloner implements AstVisitor { @override ListLiteral visitListLiteral(ListLiteral node) { - ListLiteral copy = new ListLiteral( + ListLiteral copy = astFactory.listLiteral( _mapToken(node.constKeyword), _cloneNode(node.typeArguments), _mapToken(node.leftBracket), @@ -3380,7 +3400,7 @@ class IncrementalAstCloner implements AstVisitor { @override MapLiteral visitMapLiteral(MapLiteral node) { - MapLiteral copy = new MapLiteral( + MapLiteral copy = astFactory.mapLiteral( _mapToken(node.constKeyword), _cloneNode(node.typeArguments), _mapToken(node.leftBracket), @@ -3393,12 +3413,12 @@ class IncrementalAstCloner implements AstVisitor { @override MapLiteralEntry visitMapLiteralEntry(MapLiteralEntry node) => - new MapLiteralEntry(_cloneNode(node.key), _mapToken(node.separator), - _cloneNode(node.value)); + astFactory.mapLiteralEntry(_cloneNode(node.key), + _mapToken(node.separator), _cloneNode(node.value)); @override MethodDeclaration visitMethodDeclaration(MethodDeclaration node) => - new MethodDeclaration( + astFactory.methodDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.externalKeyword), @@ -3413,7 +3433,7 @@ class IncrementalAstCloner implements AstVisitor { @override MethodInvocation visitMethodInvocation(MethodInvocation node) { - MethodInvocation copy = new MethodInvocation( + MethodInvocation copy = astFactory.methodInvocation( _cloneNode(node.target), _mapToken(node.operator), _cloneNode(node.methodName), @@ -3426,25 +3446,25 @@ class IncrementalAstCloner implements AstVisitor { @override NamedExpression visitNamedExpression(NamedExpression node) { - NamedExpression copy = - new NamedExpression(_cloneNode(node.name), _cloneNode(node.expression)); + NamedExpression copy = astFactory.namedExpression( + _cloneNode(node.name), _cloneNode(node.expression)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; } @override - AstNode visitNativeClause(NativeClause node) => - new NativeClause(_mapToken(node.nativeKeyword), _cloneNode(node.name)); + AstNode visitNativeClause(NativeClause node) => astFactory.nativeClause( + _mapToken(node.nativeKeyword), _cloneNode(node.name)); @override NativeFunctionBody visitNativeFunctionBody(NativeFunctionBody node) => - new NativeFunctionBody(_mapToken(node.nativeKeyword), + astFactory.nativeFunctionBody(_mapToken(node.nativeKeyword), _cloneNode(node.stringLiteral), _mapToken(node.semicolon)); @override NullLiteral visitNullLiteral(NullLiteral node) { - NullLiteral copy = new NullLiteral(_mapToken(node.literal)); + NullLiteral copy = astFactory.nullLiteral(_mapToken(node.literal)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3453,7 +3473,7 @@ class IncrementalAstCloner implements AstVisitor { @override ParenthesizedExpression visitParenthesizedExpression( ParenthesizedExpression node) { - ParenthesizedExpression copy = new ParenthesizedExpression( + ParenthesizedExpression copy = astFactory.parenthesizedExpression( _mapToken(node.leftParenthesis), _cloneNode(node.expression), _mapToken(node.rightParenthesis)); @@ -3464,7 +3484,7 @@ class IncrementalAstCloner implements AstVisitor { @override PartDirective visitPartDirective(PartDirective node) { - PartDirective copy = new PartDirective( + PartDirective copy = astFactory.partDirective( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.partKeyword), @@ -3476,7 +3496,7 @@ class IncrementalAstCloner implements AstVisitor { @override PartOfDirective visitPartOfDirective(PartOfDirective node) { - PartOfDirective copy = new PartOfDirective( + PartOfDirective copy = astFactory.partOfDirective( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.partKeyword), @@ -3490,7 +3510,7 @@ class IncrementalAstCloner implements AstVisitor { @override PostfixExpression visitPostfixExpression(PostfixExpression node) { - PostfixExpression copy = new PostfixExpression( + PostfixExpression copy = astFactory.postfixExpression( _cloneNode(node.operand), _mapToken(node.operator)); copy.propagatedElement = node.propagatedElement; copy.propagatedType = node.propagatedType; @@ -3501,8 +3521,10 @@ class IncrementalAstCloner implements AstVisitor { @override PrefixedIdentifier visitPrefixedIdentifier(PrefixedIdentifier node) { - PrefixedIdentifier copy = new PrefixedIdentifier(_cloneNode(node.prefix), - _mapToken(node.period), _cloneNode(node.identifier)); + PrefixedIdentifier copy = astFactory.prefixedIdentifier( + _cloneNode(node.prefix), + _mapToken(node.period), + _cloneNode(node.identifier)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3510,7 +3532,7 @@ class IncrementalAstCloner implements AstVisitor { @override PrefixExpression visitPrefixExpression(PrefixExpression node) { - PrefixExpression copy = new PrefixExpression( + PrefixExpression copy = astFactory.prefixExpression( _mapToken(node.operator), _cloneNode(node.operand)); copy.propagatedElement = node.propagatedElement; copy.propagatedType = node.propagatedType; @@ -3521,7 +3543,7 @@ class IncrementalAstCloner implements AstVisitor { @override PropertyAccess visitPropertyAccess(PropertyAccess node) { - PropertyAccess copy = new PropertyAccess(_cloneNode(node.target), + PropertyAccess copy = astFactory.propertyAccess(_cloneNode(node.target), _mapToken(node.operator), _cloneNode(node.propertyName)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; @@ -3532,7 +3554,7 @@ class IncrementalAstCloner implements AstVisitor { RedirectingConstructorInvocation visitRedirectingConstructorInvocation( RedirectingConstructorInvocation node) { RedirectingConstructorInvocation copy = - new RedirectingConstructorInvocation( + astFactory.redirectingConstructorInvocation( _mapToken(node.thisKeyword), _mapToken(node.period), _cloneNode(node.constructorName), @@ -3544,7 +3566,7 @@ class IncrementalAstCloner implements AstVisitor { @override RethrowExpression visitRethrowExpression(RethrowExpression node) { RethrowExpression copy = - new RethrowExpression(_mapToken(node.rethrowKeyword)); + astFactory.rethrowExpression(_mapToken(node.rethrowKeyword)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3552,21 +3574,21 @@ class IncrementalAstCloner implements AstVisitor { @override ReturnStatement visitReturnStatement(ReturnStatement node) => - new ReturnStatement(_mapToken(node.returnKeyword), + astFactory.returnStatement(_mapToken(node.returnKeyword), _cloneNode(node.expression), _mapToken(node.semicolon)); @override ScriptTag visitScriptTag(ScriptTag node) => - new ScriptTag(_mapToken(node.scriptTag)); + astFactory.scriptTag(_mapToken(node.scriptTag)); @override - ShowCombinator visitShowCombinator(ShowCombinator node) => new ShowCombinator( - _mapToken(node.keyword), _cloneNodeList(node.shownNames)); + ShowCombinator visitShowCombinator(ShowCombinator node) => astFactory + .showCombinator(_mapToken(node.keyword), _cloneNodeList(node.shownNames)); @override SimpleFormalParameter visitSimpleFormalParameter( SimpleFormalParameter node) => - new SimpleFormalParameter( + astFactory.simpleFormalParameter( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3584,7 +3606,7 @@ class IncrementalAstCloner implements AstVisitor { // documentation comments for the parser. mappedToken = node.token; } - SimpleIdentifier copy = new SimpleIdentifier(mappedToken, + SimpleIdentifier copy = astFactory.simpleIdentifier(mappedToken, isDeclaration: node.inDeclarationContext()); copy.auxiliaryElements = node.auxiliaryElements; copy.propagatedElement = node.propagatedElement; @@ -3597,7 +3619,7 @@ class IncrementalAstCloner implements AstVisitor { @override SimpleStringLiteral visitSimpleStringLiteral(SimpleStringLiteral node) { SimpleStringLiteral copy = - new SimpleStringLiteral(_mapToken(node.literal), node.value); + astFactory.simpleStringLiteral(_mapToken(node.literal), node.value); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3606,7 +3628,7 @@ class IncrementalAstCloner implements AstVisitor { @override StringInterpolation visitStringInterpolation(StringInterpolation node) { StringInterpolation copy = - new StringInterpolation(_cloneNodeList(node.elements)); + astFactory.stringInterpolation(_cloneNodeList(node.elements)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3615,7 +3637,7 @@ class IncrementalAstCloner implements AstVisitor { @override SuperConstructorInvocation visitSuperConstructorInvocation( SuperConstructorInvocation node) { - SuperConstructorInvocation copy = new SuperConstructorInvocation( + SuperConstructorInvocation copy = astFactory.superConstructorInvocation( _mapToken(node.superKeyword), _mapToken(node.period), _cloneNode(node.constructorName), @@ -3626,14 +3648,15 @@ class IncrementalAstCloner implements AstVisitor { @override SuperExpression visitSuperExpression(SuperExpression node) { - SuperExpression copy = new SuperExpression(_mapToken(node.superKeyword)); + SuperExpression copy = + astFactory.superExpression(_mapToken(node.superKeyword)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; } @override - SwitchCase visitSwitchCase(SwitchCase node) => new SwitchCase( + SwitchCase visitSwitchCase(SwitchCase node) => astFactory.switchCase( _cloneNodeList(node.labels), _mapToken(node.keyword), _cloneNode(node.expression), @@ -3641,15 +3664,16 @@ class IncrementalAstCloner implements AstVisitor { _cloneNodeList(node.statements)); @override - SwitchDefault visitSwitchDefault(SwitchDefault node) => new SwitchDefault( - _cloneNodeList(node.labels), - _mapToken(node.keyword), - _mapToken(node.colon), - _cloneNodeList(node.statements)); + SwitchDefault visitSwitchDefault(SwitchDefault node) => + astFactory.switchDefault( + _cloneNodeList(node.labels), + _mapToken(node.keyword), + _mapToken(node.colon), + _cloneNodeList(node.statements)); @override SwitchStatement visitSwitchStatement(SwitchStatement node) => - new SwitchStatement( + astFactory.switchStatement( _mapToken(node.switchKeyword), _mapToken(node.leftParenthesis), _cloneNode(node.expression), @@ -3660,7 +3684,7 @@ class IncrementalAstCloner implements AstVisitor { @override AstNode visitSymbolLiteral(SymbolLiteral node) { - SymbolLiteral copy = new SymbolLiteral( + SymbolLiteral copy = astFactory.symbolLiteral( _mapToken(node.poundSign), _mapTokens(node.components)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; @@ -3669,7 +3693,8 @@ class IncrementalAstCloner implements AstVisitor { @override ThisExpression visitThisExpression(ThisExpression node) { - ThisExpression copy = new ThisExpression(_mapToken(node.thisKeyword)); + ThisExpression copy = + astFactory.thisExpression(_mapToken(node.thisKeyword)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; return copy; @@ -3677,7 +3702,7 @@ class IncrementalAstCloner implements AstVisitor { @override ThrowExpression visitThrowExpression(ThrowExpression node) { - ThrowExpression copy = new ThrowExpression( + ThrowExpression copy = astFactory.throwExpression( _mapToken(node.throwKeyword), _cloneNode(node.expression)); copy.propagatedType = node.propagatedType; copy.staticType = node.staticType; @@ -3687,14 +3712,14 @@ class IncrementalAstCloner implements AstVisitor { @override TopLevelVariableDeclaration visitTopLevelVariableDeclaration( TopLevelVariableDeclaration node) => - new TopLevelVariableDeclaration( + astFactory.topLevelVariableDeclaration( _cloneNode(node.documentationComment), _cloneNodeList(node.metadata), _cloneNode(node.variables), _mapToken(node.semicolon)); @override - TryStatement visitTryStatement(TryStatement node) => new TryStatement( + TryStatement visitTryStatement(TryStatement node) => astFactory.tryStatement( _mapToken(node.tryKeyword), _cloneNode(node.body), _cloneNodeList(node.catchClauses), @@ -3703,39 +3728,40 @@ class IncrementalAstCloner implements AstVisitor { @override TypeArgumentList visitTypeArgumentList(TypeArgumentList node) => - new TypeArgumentList(_mapToken(node.leftBracket), + astFactory.typeArgumentList(_mapToken(node.leftBracket), _cloneNodeList(node.arguments), _mapToken(node.rightBracket)); @override TypeName visitTypeName(TypeName node) { - TypeName copy = - new TypeName(_cloneNode(node.name), _cloneNode(node.typeArguments)); + TypeName copy = astFactory.typeName( + _cloneNode(node.name), _cloneNode(node.typeArguments)); copy.type = node.type; return copy; } @override - TypeParameter visitTypeParameter(TypeParameter node) => new TypeParameter( - _cloneNode(node.documentationComment), - _cloneNodeList(node.metadata), - _cloneNode(node.name), - _mapToken(node.extendsKeyword), - _cloneNode(node.bound)); + TypeParameter visitTypeParameter(TypeParameter node) => + astFactory.typeParameter( + _cloneNode(node.documentationComment), + _cloneNodeList(node.metadata), + _cloneNode(node.name), + _mapToken(node.extendsKeyword), + _cloneNode(node.bound)); @override TypeParameterList visitTypeParameterList(TypeParameterList node) => - new TypeParameterList(_mapToken(node.leftBracket), + astFactory.typeParameterList(_mapToken(node.leftBracket), _cloneNodeList(node.typeParameters), _mapToken(node.rightBracket)); @override VariableDeclaration visitVariableDeclaration(VariableDeclaration node) => - new VariableDeclaration(_cloneNode(node.name), _mapToken(node.equals), - _cloneNode(node.initializer)); + astFactory.variableDeclaration(_cloneNode(node.name), + _mapToken(node.equals), _cloneNode(node.initializer)); @override VariableDeclarationList visitVariableDeclarationList( VariableDeclarationList node) => - new VariableDeclarationList( + astFactory.variableDeclarationList( null, _cloneNodeList(node.metadata), _mapToken(node.keyword), @@ -3745,27 +3771,29 @@ class IncrementalAstCloner implements AstVisitor { @override VariableDeclarationStatement visitVariableDeclarationStatement( VariableDeclarationStatement node) => - new VariableDeclarationStatement( + astFactory.variableDeclarationStatement( _cloneNode(node.variables), _mapToken(node.semicolon)); @override - WhileStatement visitWhileStatement(WhileStatement node) => new WhileStatement( - _mapToken(node.whileKeyword), - _mapToken(node.leftParenthesis), - _cloneNode(node.condition), - _mapToken(node.rightParenthesis), - _cloneNode(node.body)); + WhileStatement visitWhileStatement(WhileStatement node) => + astFactory.whileStatement( + _mapToken(node.whileKeyword), + _mapToken(node.leftParenthesis), + _cloneNode(node.condition), + _mapToken(node.rightParenthesis), + _cloneNode(node.body)); @override - WithClause visitWithClause(WithClause node) => new WithClause( + WithClause visitWithClause(WithClause node) => astFactory.withClause( _mapToken(node.withKeyword), _cloneNodeList(node.mixinTypes)); @override - YieldStatement visitYieldStatement(YieldStatement node) => new YieldStatement( - _mapToken(node.yieldKeyword), - _mapToken(node.star), - _cloneNode(node.expression), - _mapToken(node.semicolon)); + YieldStatement visitYieldStatement(YieldStatement node) => + astFactory.yieldStatement( + _mapToken(node.yieldKeyword), + _mapToken(node.star), + _cloneNode(node.expression), + _mapToken(node.semicolon)); AstNode/*=E*/ _cloneNode/**/(AstNode/*=E*/ node) { if (node == null) { diff --git a/pkg/analyzer/lib/src/dart/constant/evaluation.dart b/pkg/analyzer/lib/src/dart/constant/evaluation.dart index c3353512d56..8659dfea7e3 100644 --- a/pkg/analyzer/lib/src/dart/constant/evaluation.dart +++ b/pkg/analyzer/lib/src/dart/constant/evaluation.dart @@ -29,6 +29,7 @@ import 'package:analyzer/src/generated/type_system.dart' import 'package:analyzer/src/generated/utilities_collection.dart'; import 'package:analyzer/src/generated/utilities_dart.dart' show ParameterKind; import 'package:analyzer/src/task/dart.dart'; +import 'package:analyzer/dart/ast/standard_ast_factory.dart'; /** * Helper class encapsulating the methods for evaluating constants and @@ -717,7 +718,7 @@ class ConstantEvaluationEngine { superclass.lookUpConstructor(superName, constructor.library); if (superConstructor != null) { if (superArguments == null) { - superArguments = new NodeList(null); + superArguments = astFactory.nodeList/**/(null); } evaluateSuperConstructorCall(node, fieldMap, superConstructor, diff --git a/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart b/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart index 69d3948ded0..f00cc35d308 100644 --- a/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart +++ b/pkg/analyzer/lib/src/dart/resolver/inheritance_manager.dart @@ -5,6 +5,7 @@ import 'dart:collection'; 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'; import 'package:analyzer/dart/element/type.dart'; @@ -962,8 +963,8 @@ class InheritanceManager { int numOfPositionalParameters, List namedParameters) { DynamicTypeImpl dynamicType = DynamicTypeImpl.instance; - SimpleIdentifier nameIdentifier = - new SimpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, 0)); + SimpleIdentifier nameIdentifier = astFactory + .simpleIdentifier(new StringToken(TokenType.IDENTIFIER, name, 0)); ExecutableElementImpl executable; ExecutableElement elementToMerge = elementArrayToMerge[0]; if (elementToMerge is MethodElement) { diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart index 409960d38de..411f6a945ae 100644 --- a/pkg/analyzer/lib/src/generated/parser.dart +++ b/pkg/analyzer/lib/src/generated/parser.dart @@ -8,6 +8,7 @@ import 'dart:collection'; import "dart:math" as math; 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/error/error.dart'; import 'package:analyzer/error/listener.dart'; @@ -393,14 +394,15 @@ class Parser { } else { syntheticToken = _createSyntheticToken(TokenType.IDENTIFIER); } - return new SimpleIdentifier(syntheticToken, isDeclaration: isDeclaration); + return astFactory.simpleIdentifier(syntheticToken, + isDeclaration: isDeclaration); } /** * Return a synthetic string literal. */ - SimpleStringLiteral createSyntheticStringLiteral() => - new SimpleStringLiteral(_createSyntheticToken(TokenType.STRING), ""); + SimpleStringLiteral createSyntheticStringLiteral() => astFactory + .simpleStringLiteral(_createSyntheticToken(TokenType.STRING), ""); /** * Advance to the next token in the token stream, making it the new current @@ -599,12 +601,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type.isAdditiveOperator) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseMultiplicativeExpression(); } while (_currentToken.type.isAdditiveOperator) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseMultiplicativeExpression()); } return expression; @@ -631,7 +633,8 @@ class Parser { if (_matches(TokenType.OPEN_PAREN)) { arguments = parseArgumentList(); } - return new Annotation(atSign, name, period, constructorName, arguments); + return astFactory.annotation( + atSign, name, period, constructorName, arguments); } /** @@ -653,7 +656,7 @@ class Parser { // namedArgument can have an identifier followed by a colon. // if (_matchesIdentifier() && _tokenMatches(_peek(), TokenType.COLON)) { - return new NamedExpression(parseLabel(), parseExpression2()); + return astFactory.namedExpression(parseLabel(), parseExpression2()); } else { return parseExpression2(); } @@ -674,7 +677,7 @@ class Parser { ArgumentList parseArgumentList() { Token leftParenthesis = getAndAdvance(); if (_matches(TokenType.CLOSE_PAREN)) { - return new ArgumentList(leftParenthesis, null, getAndAdvance()); + return astFactory.argumentList(leftParenthesis, null, getAndAdvance()); } // // Even though unnamed arguments must all appear before any named arguments, @@ -712,7 +715,8 @@ class Parser { // If there is, then we're more likely missing a comma and should go back // to parsing arguments. Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); - return new ArgumentList(leftParenthesis, arguments, rightParenthesis); + return astFactory.argumentList( + leftParenthesis, arguments, rightParenthesis); } finally { _inInitializer = wasInInitializer; } @@ -738,7 +742,7 @@ class Parser { } Token rightParen = _expect(TokenType.CLOSE_PAREN); Token semicolon = _expect(TokenType.SEMICOLON); - return new AssertStatement( + return astFactory.assertStatement( keyword, leftParen, expression, comma, message, rightParen, semicolon); } @@ -755,7 +759,7 @@ class Parser { Expression parseAssignableExpression(bool primaryAllowed) { if (_matchesKeyword(Keyword.SUPER)) { return parseAssignableSelector( - new SuperExpression(getAndAdvance()), false, + astFactory.superExpression(getAndAdvance()), false, allowConditional: false); } return _parseAssignableExpressionNotStartingWithSuper(primaryAllowed); @@ -786,7 +790,7 @@ class Parser { try { Expression index = parseExpression2(); Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET); - return new IndexExpression.forTarget( + return astFactory.indexExpressionForTarget( prefix, leftBracket, index, rightBracket); } finally { _inInitializer = wasInInitializer; @@ -800,13 +804,14 @@ class Parser { [_currentToken.lexeme]); } Token operator = getAndAdvance(); - return new PropertyAccess(prefix, operator, parseSimpleIdentifier()); + return astFactory.propertyAccess( + prefix, operator, parseSimpleIdentifier()); } else if (type == TokenType.INDEX) { _splitIndex(); Token leftBracket = getAndAdvance(); Expression index = parseSimpleIdentifier(); Token rightBracket = getAndAdvance(); - return new IndexExpression.forTarget( + return astFactory.indexExpressionForTarget( prefix, leftBracket, index, rightBracket); } else { if (!optional) { @@ -830,7 +835,7 @@ class Parser { AwaitExpression parseAwaitExpression() { Token awaitToken = getAndAdvance(); Expression expression = parseUnaryExpression(); - return new AwaitExpression(awaitToken, expression); + return astFactory.awaitExpression(awaitToken, expression); } /** @@ -845,12 +850,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type == TokenType.AMPERSAND) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseShiftExpression(); } while (_currentToken.type == TokenType.AMPERSAND) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseShiftExpression()); } return expression; @@ -868,12 +873,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type == TokenType.BAR) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseBitwiseXorExpression(); } while (_currentToken.type == TokenType.BAR) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseBitwiseXorExpression()); } return expression; @@ -891,12 +896,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type == TokenType.CARET) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseBitwiseAndExpression(); } while (_currentToken.type == TokenType.CARET) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseBitwiseAndExpression()); } return expression; @@ -937,7 +942,7 @@ class Parser { // there is, then we're more likely missing a semi-colon and should go back // to parsing statements. Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET); - return new Block(leftBracket, statements, rightBracket); + return astFactory.block(leftBracket, statements, rightBracket); } /** @@ -958,7 +963,7 @@ class Parser { _reportErrorForToken(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, breakKeyword); } Token semicolon = _expect(TokenType.SEMICOLON); - return new BreakStatement(breakKeyword, label, semicolon); + return astFactory.breakStatement(breakKeyword, label, semicolon); } /** @@ -992,7 +997,7 @@ class Parser { try { Expression index = parseExpression2(); Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET); - expression = new IndexExpression.forCascade( + expression = astFactory.indexExpressionForCascade( period, leftBracket, index, rightBracket); period = null; } finally { @@ -1009,21 +1014,21 @@ class Parser { do { TypeArgumentList typeArguments = _parseOptionalTypeArguments(); if (functionName != null) { - expression = new MethodInvocation(expression, period, functionName, - typeArguments, parseArgumentList()); + expression = astFactory.methodInvocation(expression, period, + functionName, typeArguments, parseArgumentList()); period = null; functionName = null; } else if (expression == null) { // It should not be possible to get here. - expression = new MethodInvocation(expression, period, + expression = astFactory.methodInvocation(expression, period, createSyntheticIdentifier(), typeArguments, parseArgumentList()); } else { - expression = new FunctionExpressionInvocation( + expression = astFactory.functionExpressionInvocation( expression, typeArguments, parseArgumentList()); } } while (_isLikelyArgumentList()); } else if (functionName != null) { - expression = new PropertyAccess(expression, period, functionName); + expression = astFactory.propertyAccess(expression, period, functionName); period = null; } assert(expression != null); @@ -1038,14 +1043,14 @@ class Parser { TypeArgumentList typeArguments = _parseOptionalTypeArguments(); Expression currentExpression = expression; if (currentExpression is PropertyAccess) { - expression = new MethodInvocation( + expression = astFactory.methodInvocation( currentExpression.target, currentExpression.operator, currentExpression.propertyName, typeArguments, parseArgumentList()); } else { - expression = new FunctionExpressionInvocation( + expression = astFactory.functionExpressionInvocation( expression, typeArguments, parseArgumentList()); } } @@ -1054,7 +1059,7 @@ class Parser { if (_currentToken.type.isAssignmentOperator) { Token operator = getAndAdvance(); _ensureAssignable(expression); - expression = new AssignmentExpression( + expression = astFactory.assignmentExpression( expression, operator, parseExpressionWithoutCascade()); } return expression; @@ -1176,7 +1181,7 @@ class Parser { rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET); _reportErrorForCurrentToken(ParserErrorCode.MISSING_CLASS_BODY); } - ClassDeclaration classDeclaration = new ClassDeclaration( + ClassDeclaration classDeclaration = astFactory.classDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, abstractKeyword, @@ -1207,8 +1212,8 @@ class Parser { Modifiers modifiers = parseModifiers(); Keyword keyword = _currentToken.keyword; if (keyword == Keyword.VOID) { - TypeName returnType = - new TypeName(new SimpleIdentifier(getAndAdvance()), null); + TypeName returnType = astFactory.typeName( + astFactory.simpleIdentifier(getAndAdvance()), null); keyword = _currentToken.keyword; Token next = _peek(); bool isFollowedByIdentifier = _tokenMatchesIdentifier(next); @@ -1327,14 +1332,15 @@ class Parser { // We appear to have found an incomplete field declaration. // _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER); - VariableDeclaration variable = - new VariableDeclaration(createSyntheticIdentifier(), null, null); + VariableDeclaration variable = astFactory.variableDeclaration( + createSyntheticIdentifier(), null, null); List variables = [variable]; - return new FieldDeclaration( + return astFactory.fieldDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, null, - new VariableDeclarationList(null, null, keyword, null, variables), + astFactory.variableDeclarationList( + null, null, keyword, null, variables), _expect(TokenType.SEMICOLON)); } _reportErrorForToken( @@ -1347,7 +1353,7 @@ class Parser { // to loose, so we'll treat it as a method declaration with a missing // name, parameters and empty body. // - return new MethodDeclaration( + return astFactory.methodDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, null, @@ -1357,9 +1363,10 @@ class Parser { null, createSyntheticIdentifier(isDeclaration: true), null, - new FormalParameterList( + astFactory.formalParameterList( null, [], null, null, null), - new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON))); + astFactory + .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON))); } return null; } else if (_tokenMatches(next, TokenType.PERIOD) && @@ -1387,7 +1394,7 @@ class Parser { modifiers.externalKeyword, _validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, - new SimpleIdentifier(methodName.token, isDeclaration: false), + astFactory.simpleIdentifier(methodName.token, isDeclaration: false), null, null, parameters); @@ -1495,7 +1502,7 @@ class Parser { modifiers.externalKeyword, _validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, - new SimpleIdentifier(methodName.token, isDeclaration: true), + astFactory.simpleIdentifier(methodName.token, isDeclaration: true), null, null, parameters); @@ -1563,9 +1570,9 @@ class Parser { */ Combinator parseCombinator() { if (_matchesString(_SHOW)) { - return new ShowCombinator(getAndAdvance(), parseIdentifierList()); + return astFactory.showCombinator(getAndAdvance(), parseIdentifierList()); } else if (_matchesString(_HIDE)) { - return new HideCombinator(getAndAdvance(), parseIdentifierList()); + return astFactory.hideCombinator(getAndAdvance(), parseIdentifierList()); } return null; } @@ -1645,7 +1652,8 @@ class Parser { Token syntheticToken = new SyntheticStringToken(TokenType.IDENTIFIER, "", sourceOffset); syntheticToken.setNext(firstToken); - return new CommentReference(null, new SimpleIdentifier(syntheticToken)); + return astFactory.commentReference( + null, astFactory.simpleIdentifier(syntheticToken)); } Token newKeyword = null; if (_tokenMatchesKeyword(firstToken, Keyword.NEW)) { @@ -1656,16 +1664,16 @@ class Parser { if (firstToken.next.type != TokenType.EOF) { return null; } - Identifier identifier = new SimpleIdentifier(firstToken); - return new CommentReference(null, identifier); + Identifier identifier = astFactory.simpleIdentifier(firstToken); + return astFactory.commentReference(null, identifier); } else if (_tokenMatchesKeyword(firstToken, Keyword.OPERATOR)) { Token secondToken = firstToken.next; if (secondToken.isUserDefinableOperator) { if (secondToken.next.type != TokenType.EOF) { return null; } - Identifier identifier = new SimpleIdentifier(secondToken); - return new CommentReference(null, identifier); + Identifier identifier = astFactory.simpleIdentifier(secondToken); + return astFactory.commentReference(null, identifier); } return null; } else if (_tokenMatchesIdentifier(firstToken)) { @@ -1675,37 +1683,37 @@ class Parser { Identifier identifier; if (_tokenMatches(secondToken, TokenType.PERIOD)) { if (thirdToken.isUserDefinableOperator) { - identifier = new PrefixedIdentifier( - new SimpleIdentifier(firstToken), + identifier = astFactory.prefixedIdentifier( + astFactory.simpleIdentifier(firstToken), secondToken, - new SimpleIdentifier(thirdToken)); + astFactory.simpleIdentifier(thirdToken)); nextToken = thirdToken.next; } else if (_tokenMatchesKeyword(thirdToken, Keyword.OPERATOR)) { Token fourthToken = thirdToken.next; if (fourthToken.isUserDefinableOperator) { - identifier = new PrefixedIdentifier( - new SimpleIdentifier(firstToken), + identifier = astFactory.prefixedIdentifier( + astFactory.simpleIdentifier(firstToken), secondToken, - new SimpleIdentifier(fourthToken)); + astFactory.simpleIdentifier(fourthToken)); nextToken = fourthToken.next; } else { return null; } } else if (_tokenMatchesIdentifier(thirdToken)) { - identifier = new PrefixedIdentifier( - new SimpleIdentifier(firstToken), + identifier = astFactory.prefixedIdentifier( + astFactory.simpleIdentifier(firstToken), secondToken, - new SimpleIdentifier(thirdToken)); + astFactory.simpleIdentifier(thirdToken)); nextToken = thirdToken.next; } } else { - identifier = new SimpleIdentifier(firstToken); + identifier = astFactory.simpleIdentifier(firstToken); nextToken = firstToken.next; } if (nextToken.type != TokenType.EOF) { return null; } - return new CommentReference(newKeyword, identifier); + return astFactory.commentReference(newKeyword, identifier); } else { Keyword keyword = firstToken.keyword; if (keyword == Keyword.THIS || @@ -1795,8 +1803,8 @@ class Parser { TokenType.IDENTIFIER, '', nameOffset); } nameToken.setNext(new SimpleToken(TokenType.EOF, nameToken.end)); - references.add( - new CommentReference(null, new SimpleIdentifier(nameToken))); + references.add(astFactory.commentReference( + null, astFactory.simpleIdentifier(nameToken))); token.references.add(nameToken); // next character rightIndex = leftIndex + 1; @@ -1840,7 +1848,7 @@ class Parser { Token firstToken = _currentToken; ScriptTag scriptTag = null; if (_matches(TokenType.SCRIPT_TAG)) { - scriptTag = new ScriptTag(getAndAdvance()); + scriptTag = astFactory.scriptTag(getAndAdvance()); } // // Even though all directives must appear before declarations and must occur @@ -1971,7 +1979,7 @@ class Parser { // } } } - return new CompilationUnit( + return astFactory.compilationUnit( firstToken, scriptTag, directives, declarations, _currentToken); } @@ -2012,8 +2020,8 @@ class Parser { _validateModifiersForEnum(modifiers); return parseEnumDeclaration(commentAndMetadata); } else if (keyword == Keyword.VOID) { - TypeName returnType = - new TypeName(new SimpleIdentifier(getAndAdvance()), null); + TypeName returnType = astFactory.typeName( + astFactory.simpleIdentifier(getAndAdvance()), null); keyword = _currentToken.keyword; next = _peek(); if ((keyword == Keyword.GET || keyword == Keyword.SET) && @@ -2052,7 +2060,7 @@ class Parser { // We appear to have a variable declaration with a type of "void". // _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType); - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationListAfterType(null, @@ -2089,13 +2097,14 @@ class Parser { // We appear to have found an incomplete top-level variable declaration. // _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER); - VariableDeclaration variable = - new VariableDeclaration(createSyntheticIdentifier(), null, null); + VariableDeclaration variable = astFactory.variableDeclaration( + createSyntheticIdentifier(), null, null); List variables = [variable]; - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, - new VariableDeclarationList(null, null, keyword, null, variables), + astFactory.variableDeclarationList( + null, null, keyword, null, variables), _expect(TokenType.SEMICOLON)); } _reportErrorForToken(ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken); @@ -2119,7 +2128,7 @@ class Parser { _reportErrorForCurrentToken( ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE); } - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationListAfterType( @@ -2142,7 +2151,7 @@ class Parser { returnType, getAndAdvance())); } else if (_matches(TokenType.AT)) { - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationListAfterType(null, @@ -2158,13 +2167,14 @@ class Parser { } else { semicolon = _createSyntheticToken(TokenType.SEMICOLON); } - VariableDeclaration variable = - new VariableDeclaration(createSyntheticIdentifier(), null, null); + VariableDeclaration variable = astFactory.variableDeclaration( + createSyntheticIdentifier(), null, null); List variables = [variable]; - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, - new VariableDeclarationList(null, null, null, returnType, variables), + astFactory.variableDeclarationList( + null, null, null, returnType, variables), semicolon); } else if (next.matchesAny(const [ TokenType.OPEN_PAREN, @@ -2176,7 +2186,7 @@ class Parser { return parseFunctionDeclaration( commentAndMetadata, modifiers.externalKeyword, returnType); } - return new TopLevelVariableDeclaration( + return astFactory.topLevelVariableDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, parseVariableDeclarationListAfterType( @@ -2200,7 +2210,7 @@ class Parser { Expression thenExpression = parseExpressionWithoutCascade(); Token colon = _expect(TokenType.COLON); Expression elseExpression = parseExpressionWithoutCascade(); - return new ConditionalExpression( + return astFactory.conditionalExpression( condition, question, thenExpression, colon, elseExpression); } @@ -2234,8 +2244,8 @@ class Parser { } Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); StringLiteral libraryUri = _parseUri(); - return new Configuration(ifKeyword, leftParenthesis, name, equalToken, - value, rightParenthesis, libraryUri); + return astFactory.configuration(ifKeyword, leftParenthesis, name, + equalToken, value, rightParenthesis, libraryUri); } /** @@ -2292,8 +2302,12 @@ class Parser { type != TokenType.FUNCTION) { equals = _createSyntheticToken(TokenType.EQ); } else { - return new ConstructorFieldInitializer(keywordToken, period, fieldName, - _createSyntheticToken(TokenType.EQ), createSyntheticIdentifier()); + return astFactory.constructorFieldInitializer( + keywordToken, + period, + fieldName, + _createSyntheticToken(TokenType.EQ), + createSyntheticIdentifier()); } } bool wasInInitializer = _inInitializer; @@ -2308,9 +2322,9 @@ class Parser { cascadeSections.add(section); } } while (_matches(TokenType.PERIOD_PERIOD)); - expression = new CascadeExpression(expression, cascadeSections); + expression = astFactory.cascadeExpression(expression, cascadeSections); } - return new ConstructorFieldInitializer( + return astFactory.constructorFieldInitializer( keywordToken, period, fieldName, equals, expression); } finally { _inInitializer = wasInInitializer; @@ -2332,7 +2346,7 @@ class Parser { period = getAndAdvance(); name = parseSimpleIdentifier(); } - return new ConstructorName(type, period, name); + return astFactory.constructorName(type, period, name); } /** @@ -2358,7 +2372,7 @@ class Parser { ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE, continueKeyword); } Token semicolon = _expect(TokenType.SEMICOLON); - return new ContinueStatement(continueKeyword, label, semicolon); + return astFactory.continueStatement(continueKeyword, label, semicolon); } /** @@ -2411,7 +2425,7 @@ class Parser { Token firstToken = _currentToken; ScriptTag scriptTag = null; if (_matches(TokenType.SCRIPT_TAG)) { - scriptTag = new ScriptTag(getAndAdvance()); + scriptTag = astFactory.scriptTag(getAndAdvance()); } List directives = []; while (!_matches(TokenType.EOF)) { @@ -2432,11 +2446,11 @@ class Parser { while (!_matches(TokenType.EOF)) { _advance(); } - return new CompilationUnit( + return astFactory.compilationUnit( firstToken, scriptTag, directives, null, _currentToken); } } - return new CompilationUnit( + return astFactory.compilationUnit( firstToken, scriptTag, directives, null, _currentToken); } @@ -2454,7 +2468,7 @@ class Parser { return null; } List references = parseCommentReferences(tokens); - return Comment.createDocumentationCommentWithReferences(tokens, references); + return astFactory.documentationComment(tokens, references); } /** @@ -2505,8 +2519,8 @@ class Parser { Expression condition = parseExpression2(); Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); Token semicolon = _expect(TokenType.SEMICOLON); - return new DoStatement(doKeyword, body, whileKeyword, leftParenthesis, - condition, rightParenthesis, semicolon); + return astFactory.doStatement(doKeyword, body, whileKeyword, + leftParenthesis, condition, rightParenthesis, semicolon); } finally { _inLoop = wasInLoop; } @@ -2525,7 +2539,7 @@ class Parser { while (_optional(TokenType.PERIOD)) { components.add(parseSimpleIdentifier()); } - return new DottedName(components); + return astFactory.dottedName(components); } /** @@ -2536,7 +2550,7 @@ class Parser { * emptyStatement ::= * ';' */ - Statement parseEmptyStatement() => new EmptyStatement(getAndAdvance()); + Statement parseEmptyStatement() => astFactory.emptyStatement(getAndAdvance()); /** * Parse an enum declaration. The [commentAndMetadata] is the metadata to be @@ -2577,7 +2591,7 @@ class Parser { rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET); _reportErrorForCurrentToken(ParserErrorCode.MISSING_ENUM_BODY); } - return new EnumDeclaration( + return astFactory.enumDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, keyword, @@ -2599,7 +2613,7 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type.isEqualityOperator) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseRelationalExpression(); } @@ -2609,7 +2623,7 @@ class Parser { _reportErrorForNode( ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, expression); } - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseRelationalExpression()); leftEqualityExpression = true; } @@ -2631,7 +2645,7 @@ class Parser { List configurations = _parseConfigurations(); List combinators = parseCombinators(); Token semicolon = _expect(TokenType.SEMICOLON); - return new ExportDirective( + return astFactory.exportDirective( commentAndMetadata.comment, commentAndMetadata.metadata, exportKeyword, @@ -2684,11 +2698,12 @@ class Parser { cascadeSections.add(section); } } while (_currentToken.type == TokenType.PERIOD_PERIOD); - return new CascadeExpression(expression, cascadeSections); + return astFactory.cascadeExpression(expression, cascadeSections); } else if (type.isAssignmentOperator) { Token operator = getAndAdvance(); _ensureAssignable(expression); - return new AssignmentExpression(expression, operator, parseExpression2()); + return astFactory.assignmentExpression( + expression, operator, parseExpression2()); } return expression; } @@ -2732,7 +2747,7 @@ class Parser { if (_currentToken.type.isAssignmentOperator) { Token operator = getAndAdvance(); _ensureAssignable(expression); - expression = new AssignmentExpression( + expression = astFactory.assignmentExpression( expression, operator, parseExpressionWithoutCascade()); } return expression; @@ -2751,7 +2766,7 @@ class Parser { Token keyword = getAndAdvance(); TypeName superclass = parseTypeName(false); _mustNotBeNullable(superclass, ParserErrorCode.NULLABLE_TYPE_IN_EXTENDS); - return new ExtendsClause(keyword, superclass); + return astFactory.extendsClause(keyword, superclass); } /** @@ -2822,7 +2837,7 @@ class Parser { ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP, parameter); kind = ParameterKind.POSITIONAL; } - return new DefaultFormalParameter( + return astFactory.defaultFormalParameter( parameter, kind, separator, defaultValue); } else if (type == TokenType.COLON) { Token separator = getAndAdvance(); @@ -2836,10 +2851,10 @@ class Parser { ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, parameter); kind = ParameterKind.NAMED; } - return new DefaultFormalParameter( + return astFactory.defaultFormalParameter( parameter, kind, separator, defaultValue); } else if (kind != ParameterKind.REQUIRED) { - return new DefaultFormalParameter(parameter, kind, null, null); + return astFactory.defaultFormalParameter(parameter, kind, null, null); } return parameter; } @@ -2912,9 +2927,12 @@ class Parser { (_tokenMatchesKeyword(_peek(), Keyword.IN) || _tokenMatches(_peek(), TokenType.COLON))) { SimpleIdentifier variableName = _parseSimpleIdentifierUnchecked(); - variableList = new VariableDeclarationList(commentAndMetadata.comment, - commentAndMetadata.metadata, null, null, [ - new VariableDeclaration(variableName, null, null) + variableList = astFactory.variableDeclarationList( + commentAndMetadata.comment, + commentAndMetadata.metadata, + null, + null, [ + astFactory.variableDeclaration(variableName, null, null) ]); } else if (isInitializedVariableDeclaration()) { variableList = @@ -2948,12 +2966,12 @@ class Parser { Token keyword = variableList.keyword; TypeName type = variableList.type; if (keyword != null || type != null) { - loopVariable = new DeclaredIdentifier( + loopVariable = astFactory.declaredIdentifier( commentAndMetadata.comment, commentAndMetadata.metadata, keyword, type, - new SimpleIdentifier(variable.name.token, + astFactory.simpleIdentifier(variable.name.token, isDeclaration: true)); } else { if (commentAndMetadata.hasMetadata) { @@ -2969,7 +2987,7 @@ class Parser { Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); Statement body = parseStatement2(); if (loopVariable == null) { - return new ForEachStatement.withReference( + return astFactory.forEachStatementWithReference( awaitKeyword, forKeyword, leftParenthesis, @@ -2979,7 +2997,7 @@ class Parser { rightParenthesis, body); } - return new ForEachStatement.withDeclaration( + return astFactory.forEachStatementWithDeclaration( awaitKeyword, forKeyword, leftParenthesis, @@ -3006,7 +3024,7 @@ class Parser { } Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); Statement body = parseStatement2(); - return new ForStatement( + return astFactory.forStatement( forKeyword, leftParenthesis, variableList, @@ -3053,7 +3071,7 @@ class Parser { if (!mayBeEmpty) { _reportErrorForCurrentToken(emptyErrorCode); } - return new EmptyFunctionBody(getAndAdvance()); + return astFactory.emptyFunctionBody(getAndAdvance()); } Token keyword = null; Token star = null; @@ -3102,10 +3120,10 @@ class Parser { semicolon = _expect(TokenType.SEMICOLON); } if (!_parseFunctionBodies) { - return new EmptyFunctionBody( - _createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)); } - return new ExpressionFunctionBody( + return astFactory.expressionFunctionBody( keyword, functionDefinition, expression, semicolon); } else if (type == TokenType.OPEN_CURLY_BRACKET) { if (keyword != null) { @@ -3116,23 +3134,23 @@ class Parser { } if (!_parseFunctionBodies) { _skipBlock(); - return new EmptyFunctionBody( - _createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)); } - return new BlockFunctionBody(keyword, star, parseBlock()); + return astFactory.blockFunctionBody(keyword, star, parseBlock()); } else if (_matchesString(_NATIVE)) { Token nativeToken = getAndAdvance(); StringLiteral stringLiteral = null; if (_matches(TokenType.STRING)) { stringLiteral = _parseStringLiteralUnchecked(); } - return new NativeFunctionBody( + return astFactory.nativeFunctionBody( nativeToken, stringLiteral, _expect(TokenType.SEMICOLON)); } else { // Invalid function body _reportErrorForCurrentToken(emptyErrorCode); - return new EmptyFunctionBody( - _createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)); } } finally { _inAsync = wasInAsync; @@ -3170,7 +3188,7 @@ class Parser { keywordToken = getAndAdvance(); } if (keywordToken != null && _matches(TokenType.OPEN_PAREN)) { - name = new SimpleIdentifier(keywordToken, isDeclaration: true); + name = astFactory.simpleIdentifier(keywordToken, isDeclaration: true); keywordToken = null; isGetter = false; } else { @@ -3185,7 +3203,7 @@ class Parser { } else { _reportErrorForCurrentToken( ParserErrorCode.MISSING_FUNCTION_PARAMETERS); - parameters = new FormalParameterList( + parameters = astFactory.formalParameterList( _createSyntheticToken(TokenType.OPEN_PAREN), null, null, @@ -3201,21 +3219,21 @@ class Parser { body = parseFunctionBody( false, ParserErrorCode.MISSING_FUNCTION_BODY, false); } else { - body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON)); + body = astFactory.emptyFunctionBody(_expect(TokenType.SEMICOLON)); } // if (!isStatement && matches(TokenType.SEMICOLON)) { // // TODO(brianwilkerson) Improve this error message. // reportError(ParserErrorCode.UNEXPECTED_TOKEN, currentToken.getLexeme()); // advance(); // } - return new FunctionDeclaration( + return astFactory.functionDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, returnType, keywordToken, name, - new FunctionExpression(typeParameters, parameters, body)); + astFactory.functionExpression(typeParameters, parameters, body)); } /** @@ -3245,7 +3263,7 @@ class Parser { _validateFormalParameterList(parameters); FunctionBody body = parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true); - return new FunctionExpression(typeParameters, parameters, body); + return astFactory.functionExpression(typeParameters, parameters, body); } /** @@ -3281,7 +3299,7 @@ class Parser { if (externalKeyword != null && body is! EmptyFunctionBody) { _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_GETTER_WITH_BODY); } - return new MethodDeclaration( + return astFactory.methodDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, @@ -3321,7 +3339,7 @@ class Parser { Expression parseIfNullExpression() { Expression expression = parseLogicalOrExpression(); while (_currentToken.type == TokenType.QUESTION_QUESTION) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseLogicalOrExpression()); } return expression; @@ -3347,7 +3365,7 @@ class Parser { elseKeyword = getAndAdvance(); elseStatement = parseStatement2(); } - return new IfStatement(ifKeyword, leftParenthesis, condition, + return astFactory.ifStatement(ifKeyword, leftParenthesis, condition, rightParenthesis, thenStatement, elseKeyword, elseStatement); } @@ -3367,7 +3385,7 @@ class Parser { _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_IMPLEMENTS); interfaces.add(typeName); } while (_optional(TokenType.COMMA)); - return new ImplementsClause(keyword, interfaces); + return astFactory.implementsClause(keyword, interfaces); } /** @@ -3413,7 +3431,7 @@ class Parser { } List combinators = parseCombinators(); Token semicolon = _expect(TokenType.SEMICOLON); - return new ImportDirective( + return astFactory.importDirective( commentAndMetadata.comment, commentAndMetadata.metadata, importKeyword, @@ -3452,7 +3470,7 @@ class Parser { TypeName type) { VariableDeclarationList fieldList = parseVariableDeclarationListAfterType(null, keyword, type); - return new FieldDeclaration( + return astFactory.fieldDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, staticKeyword, @@ -3471,7 +3489,7 @@ class Parser { InstanceCreationExpression parseInstanceCreationExpression(Token keyword) { ConstructorName constructorName = parseConstructorName(); ArgumentList argumentList = _parseArgumentListChecked(); - return new InstanceCreationExpression( + return astFactory.instanceCreationExpression( keyword, constructorName, argumentList); } @@ -3488,7 +3506,7 @@ class Parser { SimpleIdentifier label = _parseSimpleIdentifierUnchecked(isDeclaration: isDeclaration); Token colon = getAndAdvance(); - return new Label(label, colon); + return astFactory.label(label, colon); } /** @@ -3507,7 +3525,7 @@ class Parser { LibraryIdentifier libraryName = _parseLibraryName( ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE, keyword); Token semicolon = _expect(TokenType.SEMICOLON); - return new LibraryDirective(commentAndMetadata.comment, + return astFactory.libraryDirective(commentAndMetadata.comment, commentAndMetadata.metadata, keyword, libraryName, semicolon); } @@ -3523,7 +3541,7 @@ class Parser { while (_optional(TokenType.PERIOD)) { components.add(parseSimpleIdentifier()); } - return new LibraryIdentifier(components); + return astFactory.libraryIdentifier(components); } /** @@ -3541,12 +3559,12 @@ class Parser { ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) { if (_matches(TokenType.INDEX)) { _splitIndex(); - return new ListLiteral( + return astFactory.listLiteral( modifier, typeArguments, getAndAdvance(), null, getAndAdvance()); } Token leftBracket = getAndAdvance(); if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) { - return new ListLiteral( + return astFactory.listLiteral( modifier, typeArguments, leftBracket, null, getAndAdvance()); } bool wasInInitializer = _inInitializer; @@ -3555,13 +3573,13 @@ class Parser { List elements = [parseExpression2()]; while (_optional(TokenType.COMMA)) { if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) { - return new ListLiteral( + return astFactory.listLiteral( modifier, typeArguments, leftBracket, elements, getAndAdvance()); } elements.add(parseExpression2()); } Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET); - return new ListLiteral( + return astFactory.listLiteral( modifier, typeArguments, leftBracket, elements, rightBracket); } finally { _inInitializer = wasInInitializer; @@ -3586,7 +3604,7 @@ class Parser { return parseListLiteral(modifier, typeArguments); } _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL); - return new ListLiteral( + return astFactory.listLiteral( modifier, typeArguments, _createSyntheticToken(TokenType.OPEN_SQUARE_BRACKET), @@ -3604,7 +3622,7 @@ class Parser { Expression parseLogicalAndExpression() { Expression expression = parseEqualityExpression(); while (_currentToken.type == TokenType.AMPERSAND_AMPERSAND) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseEqualityExpression()); } return expression; @@ -3620,7 +3638,7 @@ class Parser { Expression parseLogicalOrExpression() { Expression expression = parseLogicalAndExpression(); while (_currentToken.type == TokenType.BAR_BAR) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseLogicalAndExpression()); } return expression; @@ -3641,7 +3659,7 @@ class Parser { MapLiteral parseMapLiteral(Token modifier, TypeArgumentList typeArguments) { Token leftBracket = getAndAdvance(); if (_matches(TokenType.CLOSE_CURLY_BRACKET)) { - return new MapLiteral( + return astFactory.mapLiteral( modifier, typeArguments, leftBracket, null, getAndAdvance()); } bool wasInInitializer = _inInitializer; @@ -3650,13 +3668,13 @@ class Parser { List entries = [parseMapLiteralEntry()]; while (_optional(TokenType.COMMA)) { if (_matches(TokenType.CLOSE_CURLY_BRACKET)) { - return new MapLiteral( + return astFactory.mapLiteral( modifier, typeArguments, leftBracket, entries, getAndAdvance()); } entries.add(parseMapLiteralEntry()); } Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET); - return new MapLiteral( + return astFactory.mapLiteral( modifier, typeArguments, leftBracket, entries, rightBracket); } finally { _inInitializer = wasInInitializer; @@ -3673,7 +3691,7 @@ class Parser { Expression key = parseExpression2(); Token separator = _expect(TokenType.COLON); Expression value = parseExpression2(); - return new MapLiteralEntry(key, separator, value); + return astFactory.mapLiteralEntry(key, separator, value); } /** @@ -3773,12 +3791,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type.isMultiplicativeOperator) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseUnaryExpression(); } while (_currentToken.type.isMultiplicativeOperator) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseUnaryExpression()); } return expression; @@ -3823,7 +3841,7 @@ class Parser { if (_tokenMatches(_peek(), TokenType.STRING)) { Token afterString = skipStringLiteral(_currentToken.next); if (afterString != null && afterString.type == TokenType.COLON) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } } @@ -3846,14 +3864,14 @@ class Parser { } else if (keyword == Keyword.IF) { return parseIfStatement(); } else if (keyword == Keyword.RETHROW) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseRethrowExpression(), _expect(TokenType.SEMICOLON)); } else if (keyword == Keyword.RETURN) { return parseReturnStatement(); } else if (keyword == Keyword.SWITCH) { return parseSwitchStatement(); } else if (keyword == Keyword.THROW) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseThrowExpression(), _expect(TokenType.SEMICOLON)); } else if (keyword == Keyword.TRY) { return parseTryStatement(); @@ -3863,8 +3881,8 @@ class Parser { return parseVariableDeclarationStatementAfterMetadata( commentAndMetadata); } else if (keyword == Keyword.VOID) { - TypeName returnType = - new TypeName(new SimpleIdentifier(getAndAdvance()), null); + TypeName returnType = astFactory.typeName( + astFactory.simpleIdentifier(getAndAdvance()), null); Token next = _currentToken.next; if (_matchesIdentifier() && next.matchesAny(const [ @@ -3902,7 +3920,8 @@ class Parser { } _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT); // TODO(brianwilkerson) Recover from this error. - return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); } } else if (keyword == Keyword.CONST) { Token next = _currentToken.next; @@ -3912,7 +3931,7 @@ class Parser { TokenType.OPEN_SQUARE_BRACKET, TokenType.INDEX ])) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } else if (_tokenMatches(next, TokenType.IDENTIFIER)) { Token afterType = skipTypeName(next); @@ -3921,7 +3940,7 @@ class Parser { (_tokenMatches(afterType, TokenType.PERIOD) && _tokenMatches(afterType.next, TokenType.IDENTIFIER) && _tokenMatches(afterType.next.next, TokenType.OPEN_PAREN))) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } } @@ -3934,14 +3953,15 @@ class Parser { keyword == Keyword.NULL || keyword == Keyword.SUPER || keyword == Keyword.THIS) { - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } else { // // We have found an error of some kind. Try to recover. // _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT); - return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); } } else if (_inGenerator && _matchesString(_YIELD)) { return parseYieldStatement(); @@ -3949,7 +3969,7 @@ class Parser { if (_tokenMatchesKeyword(_peek(), Keyword.FOR)) { return parseForStatement(); } - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } else if (_matchesString(_AWAIT) && _tokenMatchesKeyword(_peek(), Keyword.FOR)) { @@ -3968,9 +3988,10 @@ class Parser { return parseFunctionDeclarationStatement(); } else if (type == TokenType.CLOSE_CURLY_BRACKET) { _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT); - return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); + return astFactory + .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON)); } else { - return new ExpressionStatement( + return astFactory.expressionStatement( parseExpression2(), _expect(TokenType.SEMICOLON)); } } @@ -4016,16 +4037,16 @@ class Parser { if (enableNnbd && _matches(TokenType.QUESTION)) { question = getAndAdvance(); } - return new FunctionTypedFormalParameter( + return astFactory.functionTypedFormalParameter( commentAndMetadata.comment, commentAndMetadata.metadata, holder.type, - new SimpleIdentifier(identifier.token, isDeclaration: true), + astFactory.simpleIdentifier(identifier.token, isDeclaration: true), typeParameters, parameters, question: question); } else { - return new FieldFormalParameter( + return astFactory.fieldFormalParameter( commentAndMetadata.comment, commentAndMetadata.metadata, holder.keyword, @@ -4055,7 +4076,7 @@ class Parser { // 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? - return new FieldFormalParameter( + return astFactory.fieldFormalParameter( commentAndMetadata.comment, commentAndMetadata.metadata, holder.keyword, @@ -4066,12 +4087,12 @@ class Parser { null, null); } - return new SimpleFormalParameter( + return astFactory.simpleFormalParameter( commentAndMetadata.comment, commentAndMetadata.metadata, holder.keyword, holder.type, - new SimpleIdentifier(identifier.token, isDeclaration: true)); + astFactory.simpleIdentifier(identifier.token, isDeclaration: true)); } /** @@ -4147,14 +4168,14 @@ class Parser { ArgumentList argumentList = parseArgumentList(); Expression currentOperand = operand; if (currentOperand is PropertyAccess) { - operand = new MethodInvocation( + operand = astFactory.methodInvocation( currentOperand.target, currentOperand.operator, currentOperand.propertyName, typeArguments, argumentList); } else { - operand = new FunctionExpressionInvocation( + operand = astFactory.functionExpressionInvocation( operand, typeArguments, argumentList); } } else { @@ -4173,7 +4194,7 @@ class Parser { } _ensureAssignable(operand); Token operator = getAndAdvance(); - return new PostfixExpression(operand, operator); + return astFactory.postfixExpression(operand, operator); } /** @@ -4236,25 +4257,25 @@ class Parser { } on FormatException { // The invalid format should have been reported by the scanner. } - return new IntegerLiteral(token, value); + return astFactory.integerLiteral(token, value); } Keyword keyword = _currentToken.keyword; if (keyword == Keyword.NULL) { - return new NullLiteral(getAndAdvance()); + return astFactory.nullLiteral(getAndAdvance()); } else if (keyword == Keyword.NEW) { return parseNewExpression(); } else if (keyword == Keyword.THIS) { - return new ThisExpression(getAndAdvance()); + return astFactory.thisExpression(getAndAdvance()); } else if (keyword == Keyword.SUPER) { // TODO(paulberry): verify with Gilad that "super" must be followed by // unconditionalAssignableSelector in this case. return parseAssignableSelector( - new SuperExpression(getAndAdvance()), false, + astFactory.superExpression(getAndAdvance()), false, allowConditional: false); } else if (keyword == Keyword.FALSE) { - return new BooleanLiteral(getAndAdvance(), false); + return astFactory.booleanLiteral(getAndAdvance(), false); } else if (keyword == Keyword.TRUE) { - return new BooleanLiteral(getAndAdvance(), true); + return astFactory.booleanLiteral(getAndAdvance(), true); } if (type == TokenType.DOUBLE) { Token token = getAndAdvance(); @@ -4264,7 +4285,7 @@ class Parser { } on FormatException { // The invalid format should have been reported by the scanner. } - return new DoubleLiteral(token, value); + return astFactory.doubleLiteral(token, value); } else if (type == TokenType.HEXADECIMAL) { Token token = getAndAdvance(); int value = null; @@ -4273,7 +4294,7 @@ class Parser { } on FormatException { // The invalid format should have been reported by the scanner. } - return new IntegerLiteral(token, value); + return astFactory.integerLiteral(token, value); } else if (keyword == Keyword.CONST) { return parseConstExpression(); } else if (type == TokenType.OPEN_PAREN) { @@ -4286,7 +4307,7 @@ class Parser { try { Expression expression = parseExpression2(); Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); - return new ParenthesizedExpression( + return astFactory.parenthesizedExpression( leftParenthesis, expression, rightParenthesis); } finally { _inInitializer = wasInInitializer; @@ -4351,7 +4372,7 @@ class Parser { } } ArgumentList argumentList = _parseArgumentListChecked(); - return new RedirectingConstructorInvocation( + return astFactory.redirectingConstructorInvocation( keyword, period, constructorName, argumentList); } @@ -4366,27 +4387,28 @@ class Parser { Expression parseRelationalExpression() { if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type.isRelationalOperator) { - Expression expression = new SuperExpression(getAndAdvance()); + Expression expression = astFactory.superExpression(getAndAdvance()); Token operator = getAndAdvance(); - return new BinaryExpression( + return astFactory.binaryExpression( expression, operator, parseBitwiseOrExpression()); } Expression expression = parseBitwiseOrExpression(); Keyword keyword = _currentToken.keyword; if (keyword == Keyword.AS) { Token asOperator = getAndAdvance(); - return new AsExpression(expression, asOperator, parseTypeName(true)); + return astFactory.asExpression( + expression, asOperator, parseTypeName(true)); } else if (keyword == Keyword.IS) { Token isOperator = getAndAdvance(); Token notOperator = null; if (_matches(TokenType.BANG)) { notOperator = getAndAdvance(); } - return new IsExpression( + return astFactory.isExpression( expression, isOperator, notOperator, parseTypeName(true)); } else if (_currentToken.type.isRelationalOperator) { Token operator = getAndAdvance(); - return new BinaryExpression( + return astFactory.binaryExpression( expression, operator, parseBitwiseOrExpression()); } return expression; @@ -4400,7 +4422,8 @@ class Parser { * rethrowExpression ::= * 'rethrow' */ - Expression parseRethrowExpression() => new RethrowExpression(getAndAdvance()); + Expression parseRethrowExpression() => + astFactory.rethrowExpression(getAndAdvance()); /** * Parse a return statement. Return the return statement that was parsed. @@ -4413,11 +4436,11 @@ class Parser { Statement parseReturnStatement() { Token returnKeyword = getAndAdvance(); if (_matches(TokenType.SEMICOLON)) { - return new ReturnStatement(returnKeyword, null, getAndAdvance()); + return astFactory.returnStatement(returnKeyword, null, getAndAdvance()); } Expression expression = parseExpression2(); Token semicolon = _expect(TokenType.SEMICOLON); - return new ReturnStatement(returnKeyword, expression, semicolon); + return astFactory.returnStatement(returnKeyword, expression, semicolon); } /** @@ -4429,7 +4452,8 @@ class Parser { */ TypeName parseReturnType() { if (_currentToken.keyword == Keyword.VOID) { - return new TypeName(new SimpleIdentifier(getAndAdvance()), null); + return astFactory.typeName( + astFactory.simpleIdentifier(getAndAdvance()), null); } else { return parseTypeName(false); } @@ -4464,7 +4488,7 @@ class Parser { if (externalKeyword != null && body is! EmptyFunctionBody) { _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY); } - return new MethodDeclaration( + return astFactory.methodDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, @@ -4489,12 +4513,12 @@ class Parser { Expression expression; if (_currentToken.keyword == Keyword.SUPER && _currentToken.next.type.isShiftOperator) { - expression = new SuperExpression(getAndAdvance()); + expression = astFactory.superExpression(getAndAdvance()); } else { expression = parseAdditiveExpression(); } while (_currentToken.type.isShiftOperator) { - expression = new BinaryExpression( + expression = astFactory.binaryExpression( expression, getAndAdvance(), parseAdditiveExpression()); } return expression; @@ -4544,7 +4568,7 @@ class Parser { if (labels == null) { return statement; } - return new LabeledStatement(labels, statement); + return astFactory.labeledStatement(labels, statement); } /** @@ -4590,7 +4614,7 @@ class Parser { constructorName = parseSimpleIdentifier(); } ArgumentList argumentList = _parseArgumentListChecked(); - return new SuperConstructorInvocation( + return astFactory.superConstructorInvocation( keyword, period, constructorName, argumentList); } @@ -4635,15 +4659,15 @@ class Parser { definedLabels.add(label); } Token colon = getAndAdvance(); - labels.add(new Label(identifier, colon)); + labels.add(astFactory.label(identifier, colon)); } Keyword keyword = _currentToken.keyword; if (keyword == Keyword.CASE) { Token caseKeyword = getAndAdvance(); Expression caseExpression = parseExpression2(); Token colon = _expect(TokenType.COLON); - members.add(new SwitchCase(labels, caseKeyword, caseExpression, colon, - _parseStatementList())); + members.add(astFactory.switchCase(labels, caseKeyword, caseExpression, + colon, _parseStatementList())); if (defaultKeyword != null) { _reportErrorForToken( ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE, @@ -4656,7 +4680,7 @@ class Parser { } defaultKeyword = getAndAdvance(); Token colon = _expect(TokenType.COLON); - members.add(new SwitchDefault( + members.add(astFactory.switchDefault( labels, defaultKeyword, colon, _parseStatementList())); } else { // We need to advance, otherwise we could end up in an infinite loop, @@ -4679,7 +4703,7 @@ class Parser { type = _currentToken.type; } Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET); - return new SwitchStatement(keyword, leftParenthesis, expression, + return astFactory.switchStatement(keyword, leftParenthesis, expression, rightParenthesis, leftBracket, members, rightBracket); } finally { _inSwitch = wasInSwitch; @@ -4716,7 +4740,7 @@ class Parser { _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER); components.add(_createSyntheticToken(TokenType.IDENTIFIER)); } - return new SymbolLiteral(poundSign, components); + return astFactory.symbolLiteral(poundSign, components); } /** @@ -4733,10 +4757,10 @@ class Parser { if (type == TokenType.SEMICOLON || type == TokenType.CLOSE_PAREN) { _reportErrorForToken( ParserErrorCode.MISSING_EXPRESSION_IN_THROW, _currentToken); - return new ThrowExpression(keyword, createSyntheticIdentifier()); + return astFactory.throwExpression(keyword, createSyntheticIdentifier()); } Expression expression = parseExpression2(); - return new ThrowExpression(keyword, expression); + return astFactory.throwExpression(keyword, expression); } /** @@ -4753,10 +4777,10 @@ class Parser { if (type == TokenType.SEMICOLON || type == TokenType.CLOSE_PAREN) { _reportErrorForToken( ParserErrorCode.MISSING_EXPRESSION_IN_THROW, _currentToken); - return new ThrowExpression(keyword, createSyntheticIdentifier()); + return astFactory.throwExpression(keyword, createSyntheticIdentifier()); } Expression expression = parseExpressionWithoutCascade(); - return new ThrowExpression(keyword, expression); + return astFactory.throwExpression(keyword, expression); } /** @@ -4806,7 +4830,7 @@ class Parser { rightParenthesis = _expect(TokenType.CLOSE_PAREN); } Block catchBody = _parseBlockChecked(); - catchClauses.add(new CatchClause( + catchClauses.add(astFactory.catchClause( onKeyword, exceptionType, catchKeyword, @@ -4824,7 +4848,7 @@ class Parser { } else if (catchClauses.isEmpty) { _reportErrorForCurrentToken(ParserErrorCode.MISSING_CATCH_OR_FINALLY); } - return new TryStatement( + return astFactory.tryStatement( tryKeyword, body, catchClauses, finallyKeyword, finallyClause); } @@ -4896,7 +4920,7 @@ class Parser { arguments.add(parseTypeName(false)); } Token rightBracket = _expectGt(); - return new TypeArgumentList(leftBracket, arguments, rightBracket); + return astFactory.typeArgumentList(leftBracket, arguments, rightBracket); } /** @@ -4931,10 +4955,10 @@ class Parser { if (_matchesKeyword(Keyword.EXTENDS)) { Token keyword = getAndAdvance(); TypeName bound = parseTypeName(false); - return new TypeParameter(commentAndMetadata.comment, + return astFactory.typeParameter(commentAndMetadata.comment, commentAndMetadata.metadata, name, keyword, bound); } - return new TypeParameter(commentAndMetadata.comment, + return astFactory.typeParameter(commentAndMetadata.comment, commentAndMetadata.metadata, name, null, null); } @@ -4954,7 +4978,8 @@ class Parser { typeParameters.add(parseTypeParameter()); } Token rightBracket = _expectGt(); - return new TypeParameterList(leftBracket, typeParameters, rightBracket); + return astFactory.typeParameterList( + leftBracket, typeParameters, rightBracket); } /** @@ -4982,12 +5007,12 @@ class Parser { // --> "prefixOperator postfixExpression" // --> "prefixOperator primary selector*" // --> "prefixOperator 'super' assignableSelector selector*" - return new PrefixExpression(operator, parseUnaryExpression()); + return astFactory.prefixExpression(operator, parseUnaryExpression()); } - return new PrefixExpression( - operator, new SuperExpression(getAndAdvance())); + return astFactory.prefixExpression( + operator, astFactory.superExpression(getAndAdvance())); } - return new PrefixExpression(operator, parseUnaryExpression()); + return astFactory.prefixExpression(operator, parseUnaryExpression()); } else if (_currentToken.type.isIncrementOperator) { Token operator = getAndAdvance(); if (_matchesKeyword(Keyword.SUPER)) { @@ -4995,7 +5020,7 @@ class Parser { if (nextType == TokenType.OPEN_SQUARE_BRACKET || nextType == TokenType.PERIOD) { // --> "prefixOperator 'super' assignableSelector selector*" - return new PrefixExpression(operator, parseUnaryExpression()); + return astFactory.prefixExpression(operator, parseUnaryExpression()); } // // Even though it is not valid to use an incrementing operator @@ -5011,18 +5036,18 @@ class Parser { secondOperator.setNext(_currentToken); firstOperator.setNext(secondOperator); operator.previous.setNext(firstOperator); - return new PrefixExpression( + return astFactory.prefixExpression( firstOperator, - new PrefixExpression( - secondOperator, new SuperExpression(getAndAdvance()))); + astFactory.prefixExpression( + secondOperator, astFactory.superExpression(getAndAdvance()))); } // Invalid operator before 'super' _reportErrorForCurrentToken( ParserErrorCode.INVALID_OPERATOR_FOR_SUPER, [operator.lexeme]); - return new PrefixExpression( - operator, new SuperExpression(getAndAdvance())); + return astFactory.prefixExpression( + operator, astFactory.superExpression(getAndAdvance())); } - return new PrefixExpression( + return astFactory.prefixExpression( operator, _parseAssignableExpressionNotStartingWithSuper(false)); } else if (type == TokenType.PLUS) { _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER); @@ -5057,7 +5082,7 @@ class Parser { equals = getAndAdvance(); initializer = parseExpression2(); } - return new VariableDeclaration(name, equals, initializer); + return astFactory.variableDeclaration(name, equals, initializer); } /** @@ -5099,7 +5124,7 @@ class Parser { while (_optional(TokenType.COMMA)) { variables.add(parseVariableDeclaration()); } - return new VariableDeclarationList(commentAndMetadata?.comment, + return astFactory.variableDeclarationList(commentAndMetadata?.comment, commentAndMetadata?.metadata, keyword, type, variables); } @@ -5124,7 +5149,7 @@ class Parser { // } // } Token semicolon = _expect(TokenType.SEMICOLON); - return new VariableDeclarationStatement(variableList, semicolon); + return astFactory.variableDeclarationStatement(variableList, semicolon); } /** @@ -5144,7 +5169,7 @@ class Parser { Expression condition = parseExpression2(); Token rightParenthesis = _expect(TokenType.CLOSE_PAREN); Statement body = parseStatement2(); - return new WhileStatement( + return astFactory.whileStatement( keyword, leftParenthesis, condition, rightParenthesis, body); } finally { _inLoop = wasInLoop; @@ -5167,7 +5192,7 @@ class Parser { _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_WITH); types.add(typeName); } while (_optional(TokenType.COMMA)); - return new WithClause(withKeyword, types); + return astFactory.withClause(withKeyword, types); } /** @@ -5186,7 +5211,7 @@ class Parser { } Expression expression = parseExpression2(); Token semicolon = _expect(TokenType.SEMICOLON); - return new YieldStatement(yieldToken, star, expression, semicolon); + return astFactory.yieldStatement(yieldToken, star, expression, semicolon); } /** @@ -5416,14 +5441,14 @@ class Parser { * captures the components of the given method declaration). */ FunctionDeclaration _convertToFunctionDeclaration(MethodDeclaration method) => - new FunctionDeclaration( + astFactory.functionDeclaration( method.documentationComment, method.metadata, method.externalKeyword, method.returnType, method.propertyKeyword, method.name, - new FunctionExpression( + astFactory.functionExpression( method.typeParameters, method.parameters, method.body)); /** @@ -5984,8 +6009,8 @@ class Parser { ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_PAREN.lexeme]); // Recovery: Look to see whether there is a close paren that isn't matched // to an open paren and if so parse the list of arguments as normal. - return new ArgumentList(_createSyntheticToken(TokenType.OPEN_PAREN), null, - _createSyntheticToken(TokenType.CLOSE_PAREN)); + return astFactory.argumentList(_createSyntheticToken(TokenType.OPEN_PAREN), + null, _createSyntheticToken(TokenType.CLOSE_PAREN)); } /** @@ -6007,7 +6032,7 @@ class Parser { message = parseExpression2(); } Token rightParen = _expect(TokenType.CLOSE_PAREN); - return new AssertInitializer( + return astFactory.assertInitializer( keyword, leftParen, expression, comma, message, rightParen); } @@ -6032,24 +6057,24 @@ class Parser { ArgumentList argumentList = parseArgumentList(); Expression currentExpression = expression; if (currentExpression is SimpleIdentifier) { - expression = new MethodInvocation( + expression = astFactory.methodInvocation( null, null, currentExpression, typeArguments, argumentList); } else if (currentExpression is PrefixedIdentifier) { - expression = new MethodInvocation( + expression = astFactory.methodInvocation( currentExpression.prefix, currentExpression.period, currentExpression.identifier, typeArguments, argumentList); } else if (currentExpression is PropertyAccess) { - expression = new MethodInvocation( + expression = astFactory.methodInvocation( currentExpression.target, currentExpression.operator, currentExpression.propertyName, typeArguments, argumentList); } else { - expression = new FunctionExpressionInvocation( + expression = astFactory.functionExpressionInvocation( expression, typeArguments, argumentList); } if (!primaryAllowed) { @@ -6061,7 +6086,7 @@ class Parser { if (identical(selectorExpression, expression)) { if (!isOptional && (expression is PrefixedIdentifier)) { PrefixedIdentifier identifier = expression as PrefixedIdentifier; - expression = new PropertyAccess( + expression = astFactory.propertyAccess( identifier.prefix, identifier.period, identifier.identifier); } return expression; @@ -6087,8 +6112,8 @@ class Parser { ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_CURLY_BRACKET.lexeme]); // Recovery: Check for an unmatched closing curly bracket and parse // statements until it is reached. - return new Block(_createSyntheticToken(TokenType.OPEN_CURLY_BRACKET), null, - _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET)); + return astFactory.block(_createSyntheticToken(TokenType.OPEN_CURLY_BRACKET), + null, _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET)); } /** @@ -6180,7 +6205,7 @@ class Parser { } semicolon = _createSyntheticToken(TokenType.SEMICOLON); } - return new ClassTypeAlias( + return astFactory.classTypeAlias( commentAndMetadata.comment, commentAndMetadata.metadata, classKeyword, @@ -6258,7 +6283,7 @@ class Parser { if (_matches(TokenType.EQ)) { separator = getAndAdvance(); redirectedConstructor = parseConstructorName(); - body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON)); + body = astFactory.emptyFunctionBody(_expect(TokenType.SEMICOLON)); if (factoryKeyword == null) { _reportErrorForNode( ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, @@ -6292,7 +6317,7 @@ class Parser { } } } - return new ConstructorDeclaration( + return astFactory.constructorDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, @@ -6334,7 +6359,7 @@ class Parser { _reportErrorForNode(ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT, commentAndMetadata.metadata[0]); } - return new EnumConstantDeclaration( + return astFactory.enumConstantDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, name); } @@ -6345,7 +6370,7 @@ class Parser { FormalParameterList _parseFormalParameterListAfterParen( Token leftParenthesis) { if (_matches(TokenType.CLOSE_PAREN)) { - return new FormalParameterList( + return astFactory.formalParameterList( leftParenthesis, null, null, null, getAndAdvance()); } // @@ -6495,7 +6520,7 @@ class Parser { // leftSquareBracket ??= leftCurlyBracket; rightSquareBracket ??= rightCurlyBracket; - return new FormalParameterList(leftParenthesis, parameters, + return astFactory.formalParameterList(leftParenthesis, parameters, leftSquareBracket, rightSquareBracket, rightParenthesis); } @@ -6532,7 +6557,7 @@ class Parser { ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword); } } - return new FunctionDeclarationStatement(declaration); + return astFactory.functionDeclarationStatement(declaration); } /** @@ -6560,14 +6585,14 @@ class Parser { TokenType type = _currentToken.type; if (type == TokenType.SEMICOLON || type == TokenType.EOF) { _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS); - FormalParameterList parameters = new FormalParameterList( + FormalParameterList parameters = astFactory.formalParameterList( _createSyntheticToken(TokenType.OPEN_PAREN), null, null, null, _createSyntheticToken(TokenType.CLOSE_PAREN)); Token semicolon = _expect(TokenType.SEMICOLON); - return new FunctionTypeAlias( + return astFactory.functionTypeAlias( commentAndMetadata.comment, commentAndMetadata.metadata, keyword, @@ -6580,7 +6605,7 @@ class Parser { FormalParameterList parameters = _parseFormalParameterListUnchecked(); _validateFormalParameterList(parameters); Token semicolon = _expect(TokenType.SEMICOLON); - return new FunctionTypeAlias( + return astFactory.functionTypeAlias( commentAndMetadata.comment, commentAndMetadata.metadata, keyword, @@ -6594,15 +6619,19 @@ class Parser { // Recovery: At the very least we should skip to the start of the next // valid compilation unit member, allowing for the possibility of finding // the typedef parameters before that point. - return new FunctionTypeAlias( + return astFactory.functionTypeAlias( commentAndMetadata.comment, commentAndMetadata.metadata, keyword, returnType, name, typeParameters, - new FormalParameterList(_createSyntheticToken(TokenType.OPEN_PAREN), - null, null, null, _createSyntheticToken(TokenType.CLOSE_PAREN)), + astFactory.formalParameterList( + _createSyntheticToken(TokenType.OPEN_PAREN), + null, + null, + null, + _createSyntheticToken(TokenType.CLOSE_PAREN)), _createSyntheticToken(TokenType.SEMICOLON)); } } @@ -6658,8 +6687,8 @@ class Parser { } else { _reportErrorForToken(missingNameError, missingNameToken); } - return new LibraryIdentifier( - [createSyntheticIdentifier()]); + return astFactory + .libraryIdentifier([createSyntheticIdentifier()]); } /** @@ -6696,7 +6725,7 @@ class Parser { _reportErrorForNode(ParserErrorCode.ABSTRACT_STATIC_METHOD, body); } } - return new MethodDeclaration( + return astFactory.methodDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, @@ -6737,7 +6766,7 @@ class Parser { (type == TokenType.OPEN_CURLY_BRACKET || type == TokenType.FUNCTION)) { _reportErrorForToken( ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous); - parameters = new FormalParameterList( + parameters = astFactory.formalParameterList( _createSyntheticToken(TokenType.OPEN_PAREN), null, null, @@ -6768,7 +6797,7 @@ class Parser { NativeClause _parseNativeClause() { Token keyword = getAndAdvance(); StringLiteral name = parseStringLiteral(); - return new NativeClause(keyword, name); + return astFactory.nativeClause(keyword, name); } /** @@ -6795,7 +6824,7 @@ class Parser { ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]); } SimpleIdentifier name = - new SimpleIdentifier(getAndAdvance(), isDeclaration: true); + astFactory.simpleIdentifier(getAndAdvance(), isDeclaration: true); if (_matches(TokenType.EQ)) { Token previous = _currentToken.previous; if ((_tokenMatches(previous, TokenType.EQ_EQ) || @@ -6813,7 +6842,7 @@ class Parser { if (externalKeyword != null && body is! EmptyFunctionBody) { _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY); } - return new MethodDeclaration( + return astFactory.methodDeclaration( commentAndMetadata.comment, commentAndMetadata.metadata, externalKeyword, @@ -6838,7 +6867,8 @@ class Parser { } Keyword keyword = _currentToken.keyword; if (keyword == Keyword.VOID) { - return new TypeName(new SimpleIdentifier(getAndAdvance()), null); + return astFactory.typeName( + astFactory.simpleIdentifier(getAndAdvance()), null); } else if (_matchesIdentifier()) { Token next = _peek(); if (keyword != Keyword.GET && @@ -6892,7 +6922,7 @@ class Parser { Token partKeyword = getAndAdvance(); StringLiteral partUri = _parseUri(); Token semicolon = _expect(TokenType.SEMICOLON); - return new PartDirective(commentAndMetadata.comment, + return astFactory.partDirective(commentAndMetadata.comment, commentAndMetadata.metadata, partKeyword, partUri, semicolon); } @@ -6913,7 +6943,7 @@ class Parser { if (enableUriInPartOf && _matches(TokenType.STRING)) { StringLiteral libraryUri = _parseUri(); Token semicolon = _expect(TokenType.SEMICOLON); - return new PartOfDirective( + return astFactory.partOfDirective( commentAndMetadata.comment, commentAndMetadata.metadata, partKeyword, @@ -6925,7 +6955,7 @@ class Parser { LibraryIdentifier libraryName = _parseLibraryName( ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE, ofKeyword); Token semicolon = _expect(TokenType.SEMICOLON); - return new PartOfDirective( + return astFactory.partOfDirective( commentAndMetadata.comment, commentAndMetadata.metadata, partKeyword, @@ -6949,7 +6979,7 @@ class Parser { } Token period = getAndAdvance(); SimpleIdentifier qualified = parseSimpleIdentifier(); - return new PrefixedIdentifier(qualifier, period, qualified); + return astFactory.prefixedIdentifier(qualifier, period, qualified); } /** @@ -6982,7 +7012,8 @@ class Parser { _reportErrorForCurrentToken( ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER); } - return new SimpleIdentifier(getAndAdvance(), isDeclaration: isDeclaration); + return astFactory.simpleIdentifier(getAndAdvance(), + isDeclaration: isDeclaration); } /** @@ -7021,7 +7052,7 @@ class Parser { */ StringInterpolation _parseStringInterpolation(Token string) { List elements = [ - new InterpolationString( + astFactory.interpolationString( string, computeStringValue(string.lexeme, true, false)) ]; bool hasMore = true; @@ -7034,8 +7065,8 @@ class Parser { try { Expression expression = parseExpression2(); Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET); - elements.add( - new InterpolationExpression(openToken, expression, rightBracket)); + elements.add(astFactory.interpolationExpression( + openToken, expression, rightBracket)); } finally { _inInitializer = wasInInitializer; } @@ -7043,24 +7074,25 @@ class Parser { Token openToken = getAndAdvance(); Expression expression = null; if (_matchesKeyword(Keyword.THIS)) { - expression = new ThisExpression(getAndAdvance()); + expression = astFactory.thisExpression(getAndAdvance()); } else { expression = parseSimpleIdentifier(); } - elements.add(new InterpolationExpression(openToken, expression, null)); + elements.add( + astFactory.interpolationExpression(openToken, expression, null)); } if (_matches(TokenType.STRING)) { string = getAndAdvance(); isExpression = _matches(TokenType.STRING_INTERPOLATION_EXPRESSION); hasMore = isExpression || _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER); - elements.add(new InterpolationString( + elements.add(astFactory.interpolationString( string, computeStringValue(string.lexeme, false, !hasMore))); } else { hasMore = false; } } - return new StringInterpolation(elements); + return astFactory.stringInterpolation(elements); } /** @@ -7080,11 +7112,13 @@ class Parser { _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER)) { strings.add(_parseStringInterpolation(string)); } else { - strings.add(new SimpleStringLiteral( + strings.add(astFactory.simpleStringLiteral( string, computeStringValue(string.lexeme, true, true))); } } while (_matches(TokenType.STRING)); - return strings.length == 1 ? strings[0] : new AdjacentStrings(strings); + return strings.length == 1 + ? strings[0] + : astFactory.adjacentStrings(strings); } TypeName _parseTypeName(bool inExpression) { @@ -7093,7 +7127,7 @@ class Parser { typeName = _parsePrefixedIdentifierUnchecked(); } else if (_matchesKeyword(Keyword.VAR)) { _reportErrorForCurrentToken(ParserErrorCode.VAR_AS_TYPE_NAME); - typeName = new SimpleIdentifier(getAndAdvance()); + typeName = astFactory.simpleIdentifier(getAndAdvance()); } else { typeName = createSyntheticIdentifier(); _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TYPE_NAME); @@ -7105,7 +7139,7 @@ class Parser { question = getAndAdvance(); } } - return new TypeName(typeName, typeArguments, question: question); + return astFactory.typeName(typeName, typeArguments, question: question); } /** @@ -7124,7 +7158,7 @@ class Parser { // TODO(jmesserly): this feels like a big hammer. Can we restrict it to // only work inside generic methods? TypeName typeFromComment = _parseOptionalTypeNameComment(); - return typeFromComment ?? new TypeName(typeName, typeArguments); + return typeFromComment ?? astFactory.typeName(typeName, typeArguments); } /** @@ -7181,7 +7215,7 @@ class Parser { _reportErrorForToken( ParserErrorCode.NON_STRING_LITERAL_AS_URI, newToken); _currentToken = endToken.next; - return new SimpleStringLiteral(newToken, value); + return astFactory.simpleStringLiteral(newToken, value); } } return parseStringLiteral(); @@ -7204,7 +7238,7 @@ class Parser { parseVariableDeclarationListAfterType( commentAndMetadata, keyword, type); Token semicolon = _expect(TokenType.SEMICOLON); - return new VariableDeclarationStatement(variableList, semicolon); + return astFactory.variableDeclarationStatement(variableList, semicolon); } /** diff --git a/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart b/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart index 4cb8cb6ca7b..724a24b2c9b 100644 --- a/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart +++ b/pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart @@ -5,9 +5,9 @@ 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'; -import 'package:analyzer/src/dart/ast/ast.dart'; import 'package:analyzer/src/generated/testing/token_factory.dart'; import 'package:analyzer/src/generated/utilities_dart.dart'; @@ -25,14 +25,14 @@ import 'package:analyzer/src/generated/utilities_dart.dart'; */ class AstTestFactory { static AdjacentStrings adjacentStrings(List strings) => - new AdjacentStrings(strings); + astFactory.adjacentStrings(strings); - static Annotation annotation(Identifier name) => new Annotation( + static Annotation annotation(Identifier name) => astFactory.annotation( TokenFactory.tokenFromType(TokenType.AT), name, null, null, null); static Annotation annotation2(Identifier name, SimpleIdentifier constructorName, ArgumentList arguments) => - new Annotation( + astFactory.annotation( TokenFactory.tokenFromType(TokenType.AT), name, constructorName == null @@ -42,16 +42,16 @@ class AstTestFactory { arguments); static ArgumentList argumentList([List arguments]) => - new ArgumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN), + astFactory.argumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN), arguments, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN)); static AsExpression asExpression(Expression expression, TypeName type) => - new AsExpression( + astFactory.asExpression( expression, TokenFactory.tokenFromKeyword(Keyword.AS), type); static AssertStatement assertStatement(Expression condition, [Expression message]) => - new AssertStatement( + astFactory.assertStatement( TokenFactory.tokenFromKeyword(Keyword.ASSERT), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), condition, @@ -62,19 +62,19 @@ class AstTestFactory { static AssignmentExpression assignmentExpression(Expression leftHandSide, TokenType operator, Expression rightHandSide) => - new AssignmentExpression( + astFactory.assignmentExpression( leftHandSide, TokenFactory.tokenFromType(operator), rightHandSide); static BlockFunctionBody asyncBlockFunctionBody( [List statements]) => - new BlockFunctionBody( + astFactory.blockFunctionBody( TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"), null, block(statements)); static ExpressionFunctionBody asyncExpressionFunctionBody( Expression expression) => - new ExpressionFunctionBody( + astFactory.expressionFunctionBody( TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"), TokenFactory.tokenFromType(TokenType.FUNCTION), expression, @@ -82,50 +82,49 @@ class AstTestFactory { static BlockFunctionBody asyncGeneratorBlockFunctionBody( [List statements]) => - new BlockFunctionBody( + astFactory.blockFunctionBody( TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"), TokenFactory.tokenFromType(TokenType.STAR), block(statements)); static AwaitExpression awaitExpression(Expression expression) => - new AwaitExpression( + astFactory.awaitExpression( TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "await"), expression); static BinaryExpression binaryExpression(Expression leftOperand, TokenType operator, Expression rightOperand) => - new BinaryExpression( + astFactory.binaryExpression( leftOperand, TokenFactory.tokenFromType(operator), rightOperand); - static Block block([List statements]) => new Block( + static Block block([List statements]) => astFactory.block( TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET), statements, TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET)); static BlockFunctionBody blockFunctionBody(Block block) => - new BlockFunctionBody(null, null, block); + astFactory.blockFunctionBody(null, null, block); static BlockFunctionBody blockFunctionBody2([List statements]) => - new BlockFunctionBody(null, null, block(statements)); + astFactory.blockFunctionBody(null, null, block(statements)); - static BooleanLiteral booleanLiteral(bool value) => new BooleanLiteral( + static BooleanLiteral booleanLiteral(bool value) => astFactory.booleanLiteral( value ? TokenFactory.tokenFromKeyword(Keyword.TRUE) : TokenFactory.tokenFromKeyword(Keyword.FALSE), value); - static BreakStatement breakStatement() => new BreakStatement( + static BreakStatement breakStatement() => astFactory.breakStatement( TokenFactory.tokenFromKeyword(Keyword.BREAK), null, TokenFactory.tokenFromType(TokenType.SEMICOLON)); - static BreakStatement breakStatement2(String label) => new BreakStatement( - TokenFactory.tokenFromKeyword(Keyword.BREAK), - identifier3(label), - TokenFactory.tokenFromType(TokenType.SEMICOLON)); + static BreakStatement breakStatement2(String label) => + astFactory.breakStatement(TokenFactory.tokenFromKeyword(Keyword.BREAK), + identifier3(label), TokenFactory.tokenFromType(TokenType.SEMICOLON)); static IndexExpression cascadedIndexExpression(Expression index) => - new IndexExpression.forCascade( + astFactory.indexExpressionForCascade( TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD), TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET), index, @@ -133,7 +132,7 @@ class AstTestFactory { static MethodInvocation cascadedMethodInvocation(String methodName, [List arguments]) => - new MethodInvocation( + astFactory.methodInvocation( null, TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD), identifier3(methodName), @@ -141,14 +140,14 @@ class AstTestFactory { argumentList(arguments)); static PropertyAccess cascadedPropertyAccess(String propertyName) => - new PropertyAccess( + astFactory.propertyAccess( null, TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD), identifier3(propertyName)); static CascadeExpression cascadeExpression(Expression target, [List cascadeSections]) => - new CascadeExpression(target, cascadeSections); + astFactory.cascadeExpression(target, cascadeSections); static CatchClause catchClause(String exceptionParameter, [List statements]) => @@ -171,7 +170,7 @@ class AstTestFactory { static CatchClause catchClause5(TypeName exceptionType, String exceptionParameter, String stackTraceParameter, [List statements]) => - new CatchClause( + astFactory.catchClause( exceptionType == null ? null : TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "on"), @@ -200,7 +199,7 @@ class AstTestFactory { WithClause withClause, ImplementsClause implementsClause, [List members]) => - new ClassDeclaration( + astFactory.classDeclaration( null, null, abstractKeyword == null @@ -223,7 +222,7 @@ class AstTestFactory { TypeName superclass, WithClause withClause, ImplementsClause implementsClause) => - new ClassTypeAlias( + astFactory.classTypeAlias( null, null, TokenFactory.tokenFromKeyword(Keyword.CLASS), @@ -267,7 +266,7 @@ class AstTestFactory { String scriptTag, List directives, List declarations) => - new CompilationUnit( + astFactory.compilationUnit( TokenFactory.tokenFromType(TokenType.EOF), scriptTag == null ? null : AstTestFactory.scriptTag(scriptTag), directives == null ? new List() : directives, @@ -278,7 +277,7 @@ class AstTestFactory { static ConditionalExpression conditionalExpression(Expression condition, Expression thenExpression, Expression elseExpression) => - new ConditionalExpression( + astFactory.conditionalExpression( condition, TokenFactory.tokenFromType(TokenType.QUESTION), thenExpression, @@ -290,7 +289,7 @@ class AstTestFactory { String name, FormalParameterList parameters, List initializers) => - new ConstructorDeclaration( + astFactory.constructorDeclaration( null, null, TokenFactory.tokenFromKeyword(Keyword.EXTERNAL), @@ -317,7 +316,7 @@ class AstTestFactory { FormalParameterList parameters, List initializers, FunctionBody body) => - new ConstructorDeclaration( + astFactory.constructorDeclaration( null, null, null, @@ -342,7 +341,7 @@ class AstTestFactory { static ConstructorFieldInitializer constructorFieldInitializer( bool prefixedWithThis, String fieldName, Expression expression) => - new ConstructorFieldInitializer( + astFactory.constructorFieldInitializer( prefixedWithThis ? TokenFactory.tokenFromKeyword(Keyword.THIS) : null, prefixedWithThis ? TokenFactory.tokenFromType(TokenType.PERIOD) @@ -352,13 +351,13 @@ class AstTestFactory { expression); static ConstructorName constructorName(TypeName type, String name) => - new ConstructorName( + astFactory.constructorName( type, name == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD), name == null ? null : identifier3(name)); static ContinueStatement continueStatement([String label]) => - new ContinueStatement( + astFactory.continueStatement( TokenFactory.tokenFromKeyword(Keyword.CONTINUE), label == null ? null : identifier3(label), TokenFactory.tokenFromType(TokenType.SEMICOLON)); @@ -369,7 +368,7 @@ class AstTestFactory { static DeclaredIdentifier declaredIdentifier2( Keyword keyword, TypeName type, String identifier) => - new DeclaredIdentifier( + astFactory.declaredIdentifier( null, null, keyword == null ? null : TokenFactory.tokenFromKeyword(keyword), @@ -385,11 +384,11 @@ class AstTestFactory { static Comment documentationComment( List tokens, List references) { - return new Comment(tokens, CommentType.DOCUMENTATION, references); + return astFactory.documentationComment(tokens, references); } static DoStatement doStatement(Statement body, Expression condition) => - new DoStatement( + astFactory.doStatement( TokenFactory.tokenFromKeyword(Keyword.DO), body, TokenFactory.tokenFromKeyword(Keyword.WHILE), @@ -398,18 +397,18 @@ class AstTestFactory { TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), TokenFactory.tokenFromType(TokenType.SEMICOLON)); - static DoubleLiteral doubleLiteral(double value) => - new DoubleLiteral(TokenFactory.tokenFromString(value.toString()), value); + static DoubleLiteral doubleLiteral(double value) => astFactory.doubleLiteral( + TokenFactory.tokenFromString(value.toString()), value); - static EmptyFunctionBody emptyFunctionBody() => - new EmptyFunctionBody(TokenFactory.tokenFromType(TokenType.SEMICOLON)); + static EmptyFunctionBody emptyFunctionBody() => astFactory + .emptyFunctionBody(TokenFactory.tokenFromType(TokenType.SEMICOLON)); - static EmptyStatement emptyStatement() => - new EmptyStatement(TokenFactory.tokenFromType(TokenType.SEMICOLON)); + static EmptyStatement emptyStatement() => astFactory + .emptyStatement(TokenFactory.tokenFromType(TokenType.SEMICOLON)); static EnumDeclaration enumDeclaration( SimpleIdentifier name, List constants) => - new EnumDeclaration( + astFactory.enumDeclaration( null, null, TokenFactory.tokenFromKeyword(Keyword.ENUM), @@ -424,7 +423,7 @@ class AstTestFactory { List constants = new List(count); for (int i = 0; i < count; i++) { - constants[i] = new EnumConstantDeclaration( + constants[i] = astFactory.enumConstantDeclaration( null, null, identifier3(constantNames[i])); } return enumDeclaration(identifier3(name), constants); @@ -432,7 +431,7 @@ class AstTestFactory { static ExportDirective exportDirective(List metadata, String uri, [List combinators]) => - new ExportDirective( + astFactory.exportDirective( null, metadata, TokenFactory.tokenFromKeyword(Keyword.EXPORT), @@ -446,22 +445,22 @@ class AstTestFactory { exportDirective(null, uri, combinators); static ExpressionFunctionBody expressionFunctionBody(Expression expression) => - new ExpressionFunctionBody( + astFactory.expressionFunctionBody( null, TokenFactory.tokenFromType(TokenType.FUNCTION), expression, TokenFactory.tokenFromType(TokenType.SEMICOLON)); static ExpressionStatement expressionStatement(Expression expression) => - new ExpressionStatement( + astFactory.expressionStatement( expression, TokenFactory.tokenFromType(TokenType.SEMICOLON)); - static ExtendsClause extendsClause(TypeName type) => - new ExtendsClause(TokenFactory.tokenFromKeyword(Keyword.EXTENDS), type); + static ExtendsClause extendsClause(TypeName type) => astFactory.extendsClause( + TokenFactory.tokenFromKeyword(Keyword.EXTENDS), type); static FieldDeclaration fieldDeclaration(bool isStatic, Keyword keyword, TypeName type, List variables) => - new FieldDeclaration( + astFactory.fieldDeclaration( null, null, isStatic ? TokenFactory.tokenFromKeyword(Keyword.STATIC) : null, @@ -475,7 +474,7 @@ class AstTestFactory { static FieldFormalParameter fieldFormalParameter( Keyword keyword, TypeName type, String identifier, [FormalParameterList parameterList]) => - new FieldFormalParameter( + astFactory.fieldFormalParameter( null, null, keyword == null ? null : TokenFactory.tokenFromKeyword(keyword), @@ -491,7 +490,7 @@ class AstTestFactory { static ForEachStatement forEachStatement(DeclaredIdentifier loopVariable, Expression iterator, Statement body) => - new ForEachStatement.withDeclaration( + astFactory.forEachStatementWithDeclaration( null, TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), @@ -503,7 +502,7 @@ class AstTestFactory { static ForEachStatement forEachStatement2( SimpleIdentifier identifier, Expression iterator, Statement body) => - new ForEachStatement.withReference( + astFactory.forEachStatementWithReference( null, TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), @@ -515,7 +514,7 @@ class AstTestFactory { static FormalParameterList formalParameterList( [List parameters]) => - new FormalParameterList( + astFactory.formalParameterList( TokenFactory.tokenFromType(TokenType.OPEN_PAREN), parameters, null, @@ -524,7 +523,7 @@ class AstTestFactory { static ForStatement forStatement(Expression initialization, Expression condition, List updaters, Statement body) => - new ForStatement( + astFactory.forStatement( TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), null, @@ -538,7 +537,7 @@ class AstTestFactory { static ForStatement forStatement2(VariableDeclarationList variableList, Expression condition, List updaters, Statement body) => - new ForStatement( + astFactory.forStatement( TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), variableList, @@ -552,7 +551,7 @@ class AstTestFactory { static FunctionDeclaration functionDeclaration(TypeName type, Keyword keyword, String name, FunctionExpression functionExpression) => - new FunctionDeclaration( + astFactory.functionDeclaration( null, null, null, @@ -566,21 +565,21 @@ class AstTestFactory { Keyword keyword, String name, FunctionExpression functionExpression) => - new FunctionDeclarationStatement( + astFactory.functionDeclarationStatement( functionDeclaration(type, keyword, name, functionExpression)); - static FunctionExpression functionExpression() => - new FunctionExpression(null, formalParameterList(), blockFunctionBody2()); + static FunctionExpression functionExpression() => astFactory + .functionExpression(null, formalParameterList(), blockFunctionBody2()); static FunctionExpression functionExpression2( FormalParameterList parameters, FunctionBody body) => - new FunctionExpression(null, parameters, body); + astFactory.functionExpression(null, parameters, body); static FunctionExpression functionExpression3( TypeParameterList typeParameters, FormalParameterList parameters, FunctionBody body) => - new FunctionExpression(typeParameters, parameters, body); + astFactory.functionExpression(typeParameters, parameters, body); static FunctionExpressionInvocation functionExpressionInvocation( Expression function, @@ -591,37 +590,39 @@ class AstTestFactory { Expression function, [TypeArgumentList typeArguments, List arguments]) => - new FunctionExpressionInvocation( + astFactory.functionExpressionInvocation( function, typeArguments, argumentList(arguments)); static FunctionTypedFormalParameter functionTypedFormalParameter( TypeName returnType, String identifier, [List parameters]) => - new FunctionTypedFormalParameter(null, null, returnType, + astFactory.functionTypedFormalParameter(null, null, returnType, identifier3(identifier), null, formalParameterList(parameters)); static HideCombinator hideCombinator(List identifiers) => - new HideCombinator(TokenFactory.tokenFromString("hide"), identifiers); + astFactory.hideCombinator( + TokenFactory.tokenFromString("hide"), identifiers); static HideCombinator hideCombinator2(List identifiers) => - new HideCombinator( + astFactory.hideCombinator( TokenFactory.tokenFromString("hide"), identifierList(identifiers)); static PrefixedIdentifier identifier( SimpleIdentifier prefix, SimpleIdentifier identifier) => - new PrefixedIdentifier( + astFactory.prefixedIdentifier( prefix, TokenFactory.tokenFromType(TokenType.PERIOD), identifier); - static SimpleIdentifier identifier3(String lexeme) => new SimpleIdentifier( - TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, lexeme)); + static SimpleIdentifier identifier3(String lexeme) => + astFactory.simpleIdentifier( + TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, lexeme)); static PrefixedIdentifier identifier4( String prefix, SimpleIdentifier identifier) => - new PrefixedIdentifier(identifier3(prefix), + astFactory.prefixedIdentifier(identifier3(prefix), TokenFactory.tokenFromType(TokenType.PERIOD), identifier); static PrefixedIdentifier identifier5(String prefix, String identifier) => - new PrefixedIdentifier( + astFactory.prefixedIdentifier( identifier3(prefix), TokenFactory.tokenFromType(TokenType.PERIOD), identifier3(identifier)); @@ -641,7 +642,7 @@ class AstTestFactory { static IfStatement ifStatement2(Expression condition, Statement thenStatement, Statement elseStatement) => - new IfStatement( + astFactory.ifStatement( TokenFactory.tokenFromKeyword(Keyword.IF), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), condition, @@ -653,13 +654,13 @@ class AstTestFactory { elseStatement); static ImplementsClause implementsClause(List types) => - new ImplementsClause( + astFactory.implementsClause( TokenFactory.tokenFromKeyword(Keyword.IMPLEMENTS), types); static ImportDirective importDirective( List metadata, String uri, bool isDeferred, String prefix, [List combinators]) => - new ImportDirective( + astFactory.importDirective( null, metadata, TokenFactory.tokenFromKeyword(Keyword.IMPORT), @@ -681,7 +682,7 @@ class AstTestFactory { importDirective(null, uri, false, prefix, combinators); static IndexExpression indexExpression(Expression array, Expression index) => - new IndexExpression.forTarget( + astFactory.indexExpressionForTarget( array, TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET), index, @@ -690,7 +691,7 @@ class AstTestFactory { static InstanceCreationExpression instanceCreationExpression( Keyword keyword, ConstructorName name, [List arguments]) => - new InstanceCreationExpression( + astFactory.instanceCreationExpression( keyword == null ? null : TokenFactory.tokenFromKeyword(keyword), name, argumentList(arguments)); @@ -705,7 +706,7 @@ class AstTestFactory { [List arguments]) => instanceCreationExpression( keyword, - new ConstructorName( + astFactory.constructorName( type, identifier == null ? null @@ -713,44 +714,48 @@ class AstTestFactory { identifier == null ? null : identifier3(identifier)), arguments); - static IntegerLiteral integer(int value) => new IntegerLiteral( + static IntegerLiteral integer(int value) => astFactory.integerLiteral( TokenFactory.tokenFromTypeAndString(TokenType.INT, value.toString()), value); static InterpolationExpression interpolationExpression( Expression expression) => - new InterpolationExpression( + astFactory.interpolationExpression( TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION), expression, TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET)); static InterpolationExpression interpolationExpression2(String identifier) => - new InterpolationExpression( + astFactory.interpolationExpression( TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_IDENTIFIER), identifier3(identifier), null); static InterpolationString interpolationString( String contents, String value) => - new InterpolationString(TokenFactory.tokenFromString(contents), value); + astFactory.interpolationString( + TokenFactory.tokenFromString(contents), value); static IsExpression isExpression( Expression expression, bool negated, TypeName type) => - new IsExpression(expression, TokenFactory.tokenFromKeyword(Keyword.IS), - negated ? TokenFactory.tokenFromType(TokenType.BANG) : null, type); + astFactory.isExpression( + expression, + TokenFactory.tokenFromKeyword(Keyword.IS), + negated ? TokenFactory.tokenFromType(TokenType.BANG) : null, + type); static Label label(SimpleIdentifier label) => - new Label(label, TokenFactory.tokenFromType(TokenType.COLON)); + astFactory.label(label, TokenFactory.tokenFromType(TokenType.COLON)); static Label label2(String label) => AstTestFactory.label(identifier3(label)); static LabeledStatement labeledStatement( List