Revert "Transition analyzer and analysis_server to new astFactory; remove old AST factory methods."

pkg/analyzer/lib/src/generated/testing/ast_test_factory.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.testing.ast_test_factory;
 
 import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
+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';
 
 /**
  * The class `AstTestFactory` defines utility methods that can be used to create AST nodes. The
  * nodes that are created are complete in the sense that all of the tokens that would have been
  * associated with the nodes by a parser are also created, but the token stream is not constructed.
  * None of the nodes are resolved.
  *
  * The general pattern is for the name of the factory method to be the same as the name of the class
  * of AST node being created. There are two notable exceptions. The first is for methods creating
  * nodes that are part of a cascade expression. These methods are all prefixed with 'cascaded'. The
  * second is places where a shorter name seemed unambiguous and easier to read, such as using
  * 'identifier' rather than 'prefixedIdentifier', or 'integer' rather than 'integerLiteral'.
  */
 class AstTestFactory {
   static AdjacentStrings adjacentStrings(List<StringLiteral> strings) =>
-      astFactory.adjacentStrings(strings);
+      new AdjacentStrings(strings);
 
-  static Annotation annotation(Identifier name) => astFactory.annotation(
+  static Annotation annotation(Identifier name) => new Annotation(
       TokenFactory.tokenFromType(TokenType.AT), name, null, null, null);
 
   static Annotation annotation2(Identifier name,
           SimpleIdentifier constructorName, ArgumentList arguments) =>
-      astFactory.annotation(
+      new Annotation(
           TokenFactory.tokenFromType(TokenType.AT),
           name,
           constructorName == null
               ? null
               : TokenFactory.tokenFromType(TokenType.PERIOD),
           constructorName,
           arguments);
 
   static ArgumentList argumentList([List<Expression> arguments]) =>
-      astFactory.argumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
+      new ArgumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           arguments, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
   static AsExpression asExpression(Expression expression, TypeName type) =>
-      astFactory.asExpression(
+      new AsExpression(
           expression, TokenFactory.tokenFromKeyword(Keyword.AS), type);
 
   static AssertStatement assertStatement(Expression condition,
           [Expression message]) =>
-      astFactory.assertStatement(
+      new AssertStatement(
           TokenFactory.tokenFromKeyword(Keyword.ASSERT),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
           message == null ? null : TokenFactory.tokenFromType(TokenType.COMMA),
           message,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static AssignmentExpression assignmentExpression(Expression leftHandSide,
           TokenType operator, Expression rightHandSide) =>
-      astFactory.assignmentExpression(
+      new AssignmentExpression(
           leftHandSide, TokenFactory.tokenFromType(operator), rightHandSide);
 
   static BlockFunctionBody asyncBlockFunctionBody(
           [List<Statement> statements]) =>
-      astFactory.blockFunctionBody(
+      new BlockFunctionBody(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"),
           null,
           block(statements));
 
   static ExpressionFunctionBody asyncExpressionFunctionBody(
           Expression expression) =>
-      astFactory.expressionFunctionBody(
+      new ExpressionFunctionBody(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"),
           TokenFactory.tokenFromType(TokenType.FUNCTION),
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static BlockFunctionBody asyncGeneratorBlockFunctionBody(
           [List<Statement> statements]) =>
-      astFactory.blockFunctionBody(
+      new BlockFunctionBody(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "async"),
           TokenFactory.tokenFromType(TokenType.STAR),
           block(statements));
 
   static AwaitExpression awaitExpression(Expression expression) =>
-      astFactory.awaitExpression(
+      new AwaitExpression(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "await"),
           expression);
 
   static BinaryExpression binaryExpression(Expression leftOperand,
           TokenType operator, Expression rightOperand) =>
-      astFactory.binaryExpression(
+      new BinaryExpression(
           leftOperand, TokenFactory.tokenFromType(operator), rightOperand);
 
-  static Block block([List<Statement> statements]) => astFactory.block(
+  static Block block([List<Statement> statements]) => new Block(
       TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
       statements,
       TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static BlockFunctionBody blockFunctionBody(Block block) =>
-      astFactory.blockFunctionBody(null, null, block);
+      new BlockFunctionBody(null, null, block);
 
   static BlockFunctionBody blockFunctionBody2([List<Statement> statements]) =>
-      astFactory.blockFunctionBody(null, null, block(statements));
+      new BlockFunctionBody(null, null, block(statements));
 
-  static BooleanLiteral booleanLiteral(bool value) => astFactory.booleanLiteral(
+  static BooleanLiteral booleanLiteral(bool value) => new BooleanLiteral(
       value
           ? TokenFactory.tokenFromKeyword(Keyword.TRUE)
           : TokenFactory.tokenFromKeyword(Keyword.FALSE),
       value);
 
-  static BreakStatement breakStatement() => astFactory.breakStatement(
+  static BreakStatement breakStatement() => new BreakStatement(
       TokenFactory.tokenFromKeyword(Keyword.BREAK),
       null,
       TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static BreakStatement breakStatement2(String label) =>
-      astFactory.breakStatement(TokenFactory.tokenFromKeyword(Keyword.BREAK),
-          identifier3(label), TokenFactory.tokenFromType(TokenType.SEMICOLON));
+  static BreakStatement breakStatement2(String label) => new BreakStatement(
+      TokenFactory.tokenFromKeyword(Keyword.BREAK),
+      identifier3(label),
+      TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static IndexExpression cascadedIndexExpression(Expression index) =>
-      astFactory.indexExpressionForCascade(
+      new IndexExpression.forCascade(
           TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
           TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET),
           index,
           TokenFactory.tokenFromType(TokenType.CLOSE_SQUARE_BRACKET));
 
   static MethodInvocation cascadedMethodInvocation(String methodName,
           [List<Expression> arguments]) =>
-      astFactory.methodInvocation(
+      new MethodInvocation(
           null,
           TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
           identifier3(methodName),
           null,
           argumentList(arguments));
 
   static PropertyAccess cascadedPropertyAccess(String propertyName) =>
-      astFactory.propertyAccess(
+      new PropertyAccess(
           null,
           TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD),
           identifier3(propertyName));
 
   static CascadeExpression cascadeExpression(Expression target,
           [List<Expression> cascadeSections]) =>
-      astFactory.cascadeExpression(target, cascadeSections);
+      new CascadeExpression(target, cascadeSections);
 
   static CatchClause catchClause(String exceptionParameter,
           [List<Statement> statements]) =>
       catchClause5(null, exceptionParameter, null, statements);
 
   static CatchClause catchClause2(
           String exceptionParameter, String stackTraceParameter,
           [List<Statement> statements]) =>
       catchClause5(null, exceptionParameter, stackTraceParameter, statements);
 
   static CatchClause catchClause3(TypeName exceptionType,
           [List<Statement> statements]) =>
       catchClause5(exceptionType, null, null, statements);
 
   static CatchClause catchClause4(
           TypeName exceptionType, String exceptionParameter,
           [List<Statement> statements]) =>
       catchClause5(exceptionType, exceptionParameter, null, statements);
 
   static CatchClause catchClause5(TypeName exceptionType,
           String exceptionParameter, String stackTraceParameter,
           [List<Statement> statements]) =>
-      astFactory.catchClause(
+      new CatchClause(
           exceptionType == null
               ? null
               : TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "on"),
           exceptionType,
           exceptionParameter == null
               ? null
               : TokenFactory.tokenFromKeyword(Keyword.CATCH),
           exceptionParameter == null
               ? null
               : TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           exceptionParameter == null ? null : identifier3(exceptionParameter),
           stackTraceParameter == null
               ? null
               : TokenFactory.tokenFromType(TokenType.COMMA),
           stackTraceParameter == null ? null : identifier3(stackTraceParameter),
           exceptionParameter == null
               ? null
               : TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           block(statements));
 
   static ClassDeclaration classDeclaration(
           Keyword abstractKeyword,
           String name,
           TypeParameterList typeParameters,
           ExtendsClause extendsClause,
           WithClause withClause,
           ImplementsClause implementsClause,
           [List<ClassMember> members]) =>
-      astFactory.classDeclaration(
+      new ClassDeclaration(
           null,
           null,
           abstractKeyword == null
               ? null
               : TokenFactory.tokenFromKeyword(abstractKeyword),
           TokenFactory.tokenFromKeyword(Keyword.CLASS),
           identifier3(name),
           typeParameters,
           extendsClause,
           withClause,
           implementsClause,
           TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
           members,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static ClassTypeAlias classTypeAlias(
           String name,
           TypeParameterList typeParameters,
           Keyword abstractKeyword,
           TypeName superclass,
           WithClause withClause,
           ImplementsClause implementsClause) =>
-      astFactory.classTypeAlias(
+      new ClassTypeAlias(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.CLASS),
           identifier3(name),
           typeParameters,
           TokenFactory.tokenFromType(TokenType.EQ),
           abstractKeyword == null
               ? null
               : TokenFactory.tokenFromKeyword(abstractKeyword),
           superclass,
@@ skipping 23 matching lines @@
       compilationUnit8(scriptTag, null, declarations);
 
   static CompilationUnit compilationUnit7(
           String scriptTag, List<Directive> directives) =>
       compilationUnit8(scriptTag, directives, null);
 
   static CompilationUnit compilationUnit8(
           String scriptTag,
           List<Directive> directives,
           List<CompilationUnitMember> declarations) =>
-      astFactory.compilationUnit(
+      new CompilationUnit(
           TokenFactory.tokenFromType(TokenType.EOF),
           scriptTag == null ? null : AstTestFactory.scriptTag(scriptTag),
           directives == null ? new List<Directive>() : directives,
           declarations == null
               ? new List<CompilationUnitMember>()
               : declarations,
           TokenFactory.tokenFromType(TokenType.EOF));
 
   static ConditionalExpression conditionalExpression(Expression condition,
           Expression thenExpression, Expression elseExpression) =>
-      astFactory.conditionalExpression(
+      new ConditionalExpression(
           condition,
           TokenFactory.tokenFromType(TokenType.QUESTION),
           thenExpression,
           TokenFactory.tokenFromType(TokenType.COLON),
           elseExpression);
 
   static ConstructorDeclaration constructorDeclaration(
           Identifier returnType,
           String name,
           FormalParameterList parameters,
           List<ConstructorInitializer> initializers) =>
-      astFactory.constructorDeclaration(
+      new ConstructorDeclaration(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.EXTERNAL),
           null,
           null,
           returnType,
           name == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD),
           name == null ? null : identifier3(name),
           parameters,
           initializers == null || initializers.isEmpty
               ? null
               : TokenFactory.tokenFromType(TokenType.PERIOD),
           initializers == null
               ? new List<ConstructorInitializer>()
               : initializers,
           null,
           emptyFunctionBody());
 
   static ConstructorDeclaration constructorDeclaration2(
           Keyword constKeyword,
           Keyword factoryKeyword,
           Identifier returnType,
           String name,
           FormalParameterList parameters,
           List<ConstructorInitializer> initializers,
           FunctionBody body) =>
-      astFactory.constructorDeclaration(
+      new ConstructorDeclaration(
           null,
           null,
           null,
           constKeyword == null
               ? null
               : TokenFactory.tokenFromKeyword(constKeyword),
           factoryKeyword == null
               ? null
               : TokenFactory.tokenFromKeyword(factoryKeyword),
           returnType,
           name == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD),
           name == null ? null : identifier3(name),
           parameters,
           initializers == null || initializers.isEmpty
               ? null
               : TokenFactory.tokenFromType(TokenType.PERIOD),
           initializers == null
               ? new List<ConstructorInitializer>()
               : initializers,
           null,
           body);
 
   static ConstructorFieldInitializer constructorFieldInitializer(
           bool prefixedWithThis, String fieldName, Expression expression) =>
-      astFactory.constructorFieldInitializer(
+      new ConstructorFieldInitializer(
           prefixedWithThis ? TokenFactory.tokenFromKeyword(Keyword.THIS) : null,
           prefixedWithThis
               ? TokenFactory.tokenFromType(TokenType.PERIOD)
               : null,
           identifier3(fieldName),
           TokenFactory.tokenFromType(TokenType.EQ),
           expression);
 
   static ConstructorName constructorName(TypeName type, String name) =>
-      astFactory.constructorName(
+      new ConstructorName(
           type,
           name == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD),
           name == null ? null : identifier3(name));
 
   static ContinueStatement continueStatement([String label]) =>
-      astFactory.continueStatement(
+      new ContinueStatement(
           TokenFactory.tokenFromKeyword(Keyword.CONTINUE),
           label == null ? null : identifier3(label),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static DeclaredIdentifier declaredIdentifier(
           Keyword keyword, String identifier) =>
       declaredIdentifier2(keyword, null, identifier);
 
   static DeclaredIdentifier declaredIdentifier2(
           Keyword keyword, TypeName type, String identifier) =>
-      astFactory.declaredIdentifier(
+      new DeclaredIdentifier(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           identifier3(identifier));
 
   static DeclaredIdentifier declaredIdentifier3(String identifier) =>
       declaredIdentifier2(Keyword.VAR, null, identifier);
 
   static DeclaredIdentifier declaredIdentifier4(
           TypeName type, String identifier) =>
       declaredIdentifier2(null, type, identifier);
 
   static Comment documentationComment(
       List<Token> tokens, List<CommentReference> references) {
-    return astFactory.documentationComment(tokens, references);
+    return new Comment(tokens, CommentType.DOCUMENTATION, references);
   }
 
   static DoStatement doStatement(Statement body, Expression condition) =>
-      astFactory.doStatement(
+      new DoStatement(
           TokenFactory.tokenFromKeyword(Keyword.DO),
           body,
           TokenFactory.tokenFromKeyword(Keyword.WHILE),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static DoubleLiteral doubleLiteral(double value) => astFactory.doubleLiteral(
-      TokenFactory.tokenFromString(value.toString()), value);
+  static DoubleLiteral doubleLiteral(double value) =>
+      new DoubleLiteral(TokenFactory.tokenFromString(value.toString()), value);
 
-  static EmptyFunctionBody emptyFunctionBody() => astFactory
-      .emptyFunctionBody(TokenFactory.tokenFromType(TokenType.SEMICOLON));
+  static EmptyFunctionBody emptyFunctionBody() =>
+      new EmptyFunctionBody(TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static EmptyStatement emptyStatement() => astFactory
-      .emptyStatement(TokenFactory.tokenFromType(TokenType.SEMICOLON));
+  static EmptyStatement emptyStatement() =>
+      new EmptyStatement(TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static EnumDeclaration enumDeclaration(
           SimpleIdentifier name, List<EnumConstantDeclaration> constants) =>
-      astFactory.enumDeclaration(
+      new EnumDeclaration(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.ENUM),
           name,
           TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
           constants,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static EnumDeclaration enumDeclaration2(
       String name, List<String> constantNames) {
     int count = constantNames.length;
     List<EnumConstantDeclaration> constants =
         new List<EnumConstantDeclaration>(count);
     for (int i = 0; i < count; i++) {
-      constants[i] = astFactory.enumConstantDeclaration(
+      constants[i] = new EnumConstantDeclaration(
           null, null, identifier3(constantNames[i]));
     }
     return enumDeclaration(identifier3(name), constants);
   }
 
   static ExportDirective exportDirective(List<Annotation> metadata, String uri,
           [List<Combinator> combinators]) =>
-      astFactory.exportDirective(
+      new ExportDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.EXPORT),
           string2(uri),
           null,
           combinators,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ExportDirective exportDirective2(String uri,
           [List<Combinator> combinators]) =>
       exportDirective(null, uri, combinators);
 
   static ExpressionFunctionBody expressionFunctionBody(Expression expression) =>
-      astFactory.expressionFunctionBody(
+      new ExpressionFunctionBody(
           null,
           TokenFactory.tokenFromType(TokenType.FUNCTION),
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ExpressionStatement expressionStatement(Expression expression) =>
-      astFactory.expressionStatement(
+      new ExpressionStatement(
           expression, TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
-  static ExtendsClause extendsClause(TypeName type) => astFactory.extendsClause(
-      TokenFactory.tokenFromKeyword(Keyword.EXTENDS), type);
+  static ExtendsClause extendsClause(TypeName type) =>
+      new ExtendsClause(TokenFactory.tokenFromKeyword(Keyword.EXTENDS), type);
 
   static FieldDeclaration fieldDeclaration(bool isStatic, Keyword keyword,
           TypeName type, List<VariableDeclaration> variables) =>
-      astFactory.fieldDeclaration(
+      new FieldDeclaration(
           null,
           null,
           isStatic ? TokenFactory.tokenFromKeyword(Keyword.STATIC) : null,
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static FieldDeclaration fieldDeclaration2(bool isStatic, Keyword keyword,
           List<VariableDeclaration> variables) =>
       fieldDeclaration(isStatic, keyword, null, variables);
 
   static FieldFormalParameter fieldFormalParameter(
           Keyword keyword, TypeName type, String identifier,
           [FormalParameterList parameterList]) =>
-      astFactory.fieldFormalParameter(
+      new FieldFormalParameter(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           TokenFactory.tokenFromKeyword(Keyword.THIS),
           TokenFactory.tokenFromType(TokenType.PERIOD),
           identifier3(identifier),
           null,
           parameterList);
 
   static FieldFormalParameter fieldFormalParameter2(String identifier) =>
       fieldFormalParameter(null, null, identifier);
 
   static ForEachStatement forEachStatement(DeclaredIdentifier loopVariable,
           Expression iterator, Statement body) =>
-      astFactory.forEachStatementWithDeclaration(
+      new ForEachStatement.withDeclaration(
           null,
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           loopVariable,
           TokenFactory.tokenFromKeyword(Keyword.IN),
           iterator,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
   static ForEachStatement forEachStatement2(
           SimpleIdentifier identifier, Expression iterator, Statement body) =>
-      astFactory.forEachStatementWithReference(
+      new ForEachStatement.withReference(
           null,
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           identifier,
           TokenFactory.tokenFromKeyword(Keyword.IN),
           iterator,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
   static FormalParameterList formalParameterList(
           [List<FormalParameter> parameters]) =>
-      astFactory.formalParameterList(
+      new FormalParameterList(
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           parameters,
           null,
           null,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
   static ForStatement forStatement(Expression initialization,
           Expression condition, List<Expression> updaters, Statement body) =>
-      astFactory.forStatement(
+      new ForStatement(
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           null,
           initialization,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           condition,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           updaters,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
   static ForStatement forStatement2(VariableDeclarationList variableList,
           Expression condition, List<Expression> updaters, Statement body) =>
-      astFactory.forStatement(
+      new ForStatement(
           TokenFactory.tokenFromKeyword(Keyword.FOR),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           variableList,
           null,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           condition,
           TokenFactory.tokenFromType(TokenType.SEMICOLON),
           updaters,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
   static FunctionDeclaration functionDeclaration(TypeName type, Keyword keyword,
           String name, FunctionExpression functionExpression) =>
-      astFactory.functionDeclaration(
+      new FunctionDeclaration(
           null,
           null,
           null,
           type,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           identifier3(name),
           functionExpression);
 
   static FunctionDeclarationStatement functionDeclarationStatement(
           TypeName type,
           Keyword keyword,
           String name,
           FunctionExpression functionExpression) =>
-      astFactory.functionDeclarationStatement(
+      new FunctionDeclarationStatement(
           functionDeclaration(type, keyword, name, functionExpression));
 
-  static FunctionExpression functionExpression() => astFactory
-      .functionExpression(null, formalParameterList(), blockFunctionBody2());
+  static FunctionExpression functionExpression() =>
+      new FunctionExpression(null, formalParameterList(), blockFunctionBody2());
 
   static FunctionExpression functionExpression2(
           FormalParameterList parameters, FunctionBody body) =>
-      astFactory.functionExpression(null, parameters, body);
+      new FunctionExpression(null, parameters, body);
 
   static FunctionExpression functionExpression3(
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           FunctionBody body) =>
-      astFactory.functionExpression(typeParameters, parameters, body);
+      new FunctionExpression(typeParameters, parameters, body);
 
   static FunctionExpressionInvocation functionExpressionInvocation(
           Expression function,
           [List<Expression> arguments]) =>
       functionExpressionInvocation2(function, null, arguments);
 
   static FunctionExpressionInvocation functionExpressionInvocation2(
           Expression function,
           [TypeArgumentList typeArguments,
           List<Expression> arguments]) =>
-      astFactory.functionExpressionInvocation(
+      new FunctionExpressionInvocation(
           function, typeArguments, argumentList(arguments));
 
   static FunctionTypedFormalParameter functionTypedFormalParameter(
           TypeName returnType, String identifier,
           [List<FormalParameter> parameters]) =>
-      astFactory.functionTypedFormalParameter(null, null, returnType,
+      new FunctionTypedFormalParameter(null, null, returnType,
           identifier3(identifier), null, formalParameterList(parameters));
 
   static HideCombinator hideCombinator(List<SimpleIdentifier> identifiers) =>
-      astFactory.hideCombinator(
-          TokenFactory.tokenFromString("hide"), identifiers);
+      new HideCombinator(TokenFactory.tokenFromString("hide"), identifiers);
 
   static HideCombinator hideCombinator2(List<String> identifiers) =>
-      astFactory.hideCombinator(
+      new HideCombinator(
           TokenFactory.tokenFromString("hide"), identifierList(identifiers));
 
   static PrefixedIdentifier identifier(
           SimpleIdentifier prefix, SimpleIdentifier identifier) =>
-      astFactory.prefixedIdentifier(
+      new PrefixedIdentifier(
           prefix, TokenFactory.tokenFromType(TokenType.PERIOD), identifier);
 
-  static SimpleIdentifier identifier3(String lexeme) =>
-      astFactory.simpleIdentifier(
-          TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, lexeme));
+  static SimpleIdentifier identifier3(String lexeme) => new SimpleIdentifier(
+      TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, lexeme));
 
   static PrefixedIdentifier identifier4(
           String prefix, SimpleIdentifier identifier) =>
-      astFactory.prefixedIdentifier(identifier3(prefix),
+      new PrefixedIdentifier(identifier3(prefix),
           TokenFactory.tokenFromType(TokenType.PERIOD), identifier);
 
   static PrefixedIdentifier identifier5(String prefix, String identifier) =>
-      astFactory.prefixedIdentifier(
+      new PrefixedIdentifier(
           identifier3(prefix),
           TokenFactory.tokenFromType(TokenType.PERIOD),
           identifier3(identifier));
 
   static List<SimpleIdentifier> identifierList(List<String> identifiers) {
     if (identifiers == null) {
       return null;
     }
     return identifiers
         .map((String identifier) => identifier3(identifier))
         .toList();
   }
 
   static IfStatement ifStatement(
           Expression condition, Statement thenStatement) =>
       ifStatement2(condition, thenStatement, null);
 
   static IfStatement ifStatement2(Expression condition, Statement thenStatement,
           Statement elseStatement) =>
-      astFactory.ifStatement(
+      new IfStatement(
           TokenFactory.tokenFromKeyword(Keyword.IF),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           thenStatement,
           elseStatement == null
               ? null
               : TokenFactory.tokenFromKeyword(Keyword.ELSE),
           elseStatement);
 
   static ImplementsClause implementsClause(List<TypeName> types) =>
-      astFactory.implementsClause(
+      new ImplementsClause(
           TokenFactory.tokenFromKeyword(Keyword.IMPLEMENTS), types);
 
   static ImportDirective importDirective(
           List<Annotation> metadata, String uri, bool isDeferred, String prefix,
           [List<Combinator> combinators]) =>
-      astFactory.importDirective(
+      new ImportDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.IMPORT),
           string2(uri),
           null,
           !isDeferred ? null : TokenFactory.tokenFromKeyword(Keyword.DEFERRED),
           prefix == null ? null : TokenFactory.tokenFromKeyword(Keyword.AS),
           prefix == null ? null : identifier3(prefix),
           combinators,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ImportDirective importDirective2(
           String uri, bool isDeferred, String prefix,
           [List<Combinator> combinators]) =>
       importDirective(null, uri, isDeferred, prefix, combinators);
 
   static ImportDirective importDirective3(String uri, String prefix,
           [List<Combinator> combinators]) =>
       importDirective(null, uri, false, prefix, combinators);
 
   static IndexExpression indexExpression(Expression array, Expression index) =>
-      astFactory.indexExpressionForTarget(
+      new IndexExpression.forTarget(
           array,
           TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET),
           index,
           TokenFactory.tokenFromType(TokenType.CLOSE_SQUARE_BRACKET));
 
   static InstanceCreationExpression instanceCreationExpression(
           Keyword keyword, ConstructorName name,
           [List<Expression> arguments]) =>
-      astFactory.instanceCreationExpression(
+      new InstanceCreationExpression(
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           name,
           argumentList(arguments));
 
   static InstanceCreationExpression instanceCreationExpression2(
           Keyword keyword, TypeName type,
           [List<Expression> arguments]) =>
       instanceCreationExpression3(keyword, type, null, arguments);
 
   static InstanceCreationExpression instanceCreationExpression3(
           Keyword keyword, TypeName type, String identifier,
           [List<Expression> arguments]) =>
       instanceCreationExpression(
           keyword,
-          astFactory.constructorName(
+          new ConstructorName(
               type,
               identifier == null
                   ? null
                   : TokenFactory.tokenFromType(TokenType.PERIOD),
               identifier == null ? null : identifier3(identifier)),
           arguments);
 
-  static IntegerLiteral integer(int value) => astFactory.integerLiteral(
+  static IntegerLiteral integer(int value) => new IntegerLiteral(
       TokenFactory.tokenFromTypeAndString(TokenType.INT, value.toString()),
       value);
 
   static InterpolationExpression interpolationExpression(
           Expression expression) =>
-      astFactory.interpolationExpression(
+      new InterpolationExpression(
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_EXPRESSION),
           expression,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static InterpolationExpression interpolationExpression2(String identifier) =>
-      astFactory.interpolationExpression(
+      new InterpolationExpression(
           TokenFactory.tokenFromType(TokenType.STRING_INTERPOLATION_IDENTIFIER),
           identifier3(identifier),
           null);
 
   static InterpolationString interpolationString(
           String contents, String value) =>
-      astFactory.interpolationString(
-          TokenFactory.tokenFromString(contents), value);
+      new InterpolationString(TokenFactory.tokenFromString(contents), value);
 
   static IsExpression isExpression(
           Expression expression, bool negated, TypeName type) =>
-      astFactory.isExpression(
-          expression,
-          TokenFactory.tokenFromKeyword(Keyword.IS),
-          negated ? TokenFactory.tokenFromType(TokenType.BANG) : null,
-          type);
+      new IsExpression(expression, TokenFactory.tokenFromKeyword(Keyword.IS),
+          negated ? TokenFactory.tokenFromType(TokenType.BANG) : null, type);
 
   static Label label(SimpleIdentifier label) =>
-      astFactory.label(label, TokenFactory.tokenFromType(TokenType.COLON));
+      new Label(label, TokenFactory.tokenFromType(TokenType.COLON));
 
   static Label label2(String label) => AstTestFactory.label(identifier3(label));
 
   static LabeledStatement labeledStatement(
           List<Label> labels, Statement statement) =>
-      astFactory.labeledStatement(labels, statement);
+      new LabeledStatement(labels, statement);
 
   static LibraryDirective libraryDirective(
           List<Annotation> metadata, LibraryIdentifier libraryName) =>
-      astFactory.libraryDirective(
+      new LibraryDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.LIBRARY),
           libraryName,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static LibraryDirective libraryDirective2(String libraryName) =>
       libraryDirective(
           new List<Annotation>(), libraryIdentifier2([libraryName]));
 
   static LibraryIdentifier libraryIdentifier(
           List<SimpleIdentifier> components) =>
-      astFactory.libraryIdentifier(components);
+      new LibraryIdentifier(components);
 
   static LibraryIdentifier libraryIdentifier2(List<String> components) {
-    return astFactory.libraryIdentifier(identifierList(components));
+    return new LibraryIdentifier(identifierList(components));
   }
 
   static List list(List<Object> elements) {
     return elements;
   }
 
   static ListLiteral listLiteral([List<Expression> elements]) =>
       listLiteral2(null, null, elements);
 
   static ListLiteral listLiteral2(
           Keyword keyword, TypeArgumentList typeArguments,
           [List<Expression> elements]) =>
-      astFactory.listLiteral(
+      new ListLiteral(
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           typeArguments,
           TokenFactory.tokenFromType(TokenType.OPEN_SQUARE_BRACKET),
           elements,
           TokenFactory.tokenFromType(TokenType.CLOSE_SQUARE_BRACKET));
 
   static MapLiteral mapLiteral(Keyword keyword, TypeArgumentList typeArguments,
           [List<MapLiteralEntry> entries]) =>
-      astFactory.mapLiteral(
+      new MapLiteral(
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           typeArguments,
           TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
           entries,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static MapLiteral mapLiteral2([List<MapLiteralEntry> entries]) =>
       mapLiteral(null, null, entries);
 
   static MapLiteralEntry mapLiteralEntry(String key, Expression value) =>
-      astFactory.mapLiteralEntry(
+      new MapLiteralEntry(
           string2(key), TokenFactory.tokenFromType(TokenType.COLON), value);
 
   static MapLiteralEntry mapLiteralEntry2(Expression key, Expression value) =>
-      astFactory.mapLiteralEntry(
+      new MapLiteralEntry(
           key, TokenFactory.tokenFromType(TokenType.COLON), value);
 
   static MethodDeclaration methodDeclaration(
           Keyword modifier,
           TypeName returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           FormalParameterList parameters) =>
-      astFactory.methodDeclaration(
+      new MethodDeclaration(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.EXTERNAL),
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           null,
           parameters,
           emptyFunctionBody());
 
   static MethodDeclaration methodDeclaration2(
           Keyword modifier,
           TypeName returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           FormalParameterList parameters,
           FunctionBody body) =>
-      astFactory.methodDeclaration(
+      new MethodDeclaration(
           null,
           null,
           null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           null,
           parameters,
           body);
 
   static MethodDeclaration methodDeclaration3(
           Keyword modifier,
           TypeName returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           TypeParameterList typeParameters,
           FormalParameterList parameters,
           FunctionBody body) =>
-      astFactory.methodDeclaration(
+      new MethodDeclaration(
           null,
           null,
           null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           typeParameters,
           parameters,
           body);
 
   static MethodDeclaration methodDeclaration4(
           {bool external: false,
           Keyword modifier,
           TypeName returnType,
           Keyword property,
           bool operator: false,
           String name,
           FormalParameterList parameters,
           FunctionBody body}) =>
-      astFactory.methodDeclaration(
+      new MethodDeclaration(
           null,
           null,
           external ? TokenFactory.tokenFromKeyword(Keyword.EXTERNAL) : null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator ? TokenFactory.tokenFromKeyword(Keyword.OPERATOR) : null,
           identifier3(name),
           null,
           parameters,
           body);
 
   static MethodInvocation methodInvocation(Expression target, String methodName,
           [List<Expression> arguments,
           TokenType operator = TokenType.PERIOD]) =>
-      astFactory.methodInvocation(
+      new MethodInvocation(
           target,
           target == null ? null : TokenFactory.tokenFromType(operator),
           identifier3(methodName),
           null,
           argumentList(arguments));
 
   static MethodInvocation methodInvocation2(String methodName,
           [List<Expression> arguments]) =>
       methodInvocation(null, methodName, arguments);
 
   static MethodInvocation methodInvocation3(
           Expression target, String methodName, TypeArgumentList typeArguments,
           [List<Expression> arguments,
           TokenType operator = TokenType.PERIOD]) =>
-      astFactory.methodInvocation(
+      new MethodInvocation(
           target,
           target == null ? null : TokenFactory.tokenFromType(operator),
           identifier3(methodName),
           typeArguments,
           argumentList(arguments));
 
   static NamedExpression namedExpression(Label label, Expression expression) =>
-      astFactory.namedExpression(label, expression);
+      new NamedExpression(label, expression);
 
   static NamedExpression namedExpression2(
           String label, Expression expression) =>
       namedExpression(label2(label), expression);
 
   static DefaultFormalParameter namedFormalParameter(
           NormalFormalParameter parameter, Expression expression) =>
-      astFactory.defaultFormalParameter(
+      new DefaultFormalParameter(
           parameter,
           ParameterKind.NAMED,
           expression == null
               ? null
               : TokenFactory.tokenFromType(TokenType.COLON),
           expression);
 
-  static NativeClause nativeClause(String nativeCode) =>
-      astFactory.nativeClause(
-          TokenFactory.tokenFromString("native"), string2(nativeCode));
+  static NativeClause nativeClause(String nativeCode) => new NativeClause(
+      TokenFactory.tokenFromString("native"), string2(nativeCode));
 
   static NativeFunctionBody nativeFunctionBody(String nativeMethodName) =>
-      astFactory.nativeFunctionBody(
+      new NativeFunctionBody(
           TokenFactory.tokenFromString("native"),
           string2(nativeMethodName),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static NullLiteral nullLiteral() =>
-      astFactory.nullLiteral(TokenFactory.tokenFromKeyword(Keyword.NULL));
+      new NullLiteral(TokenFactory.tokenFromKeyword(Keyword.NULL));
 
   static ParenthesizedExpression parenthesizedExpression(
           Expression expression) =>
-      astFactory.parenthesizedExpression(
+      new ParenthesizedExpression(
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           expression,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
   static PartDirective partDirective(List<Annotation> metadata, String url) =>
-      astFactory.partDirective(
+      new PartDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.PART),
           string2(url),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static PartDirective partDirective2(String url) =>
       partDirective(new List<Annotation>(), url);
 
   static PartOfDirective partOfDirective(LibraryIdentifier libraryName) =>
       partOfDirective2(new List<Annotation>(), libraryName);
 
   static PartOfDirective partOfDirective2(
           List<Annotation> metadata, LibraryIdentifier libraryName) =>
-      astFactory.partOfDirective(
+      new PartOfDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.PART),
           TokenFactory.tokenFromString("of"),
           null,
           libraryName,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static DefaultFormalParameter positionalFormalParameter(
           NormalFormalParameter parameter, Expression expression) =>
-      astFactory.defaultFormalParameter(
+      new DefaultFormalParameter(
           parameter,
           ParameterKind.POSITIONAL,
           expression == null ? null : TokenFactory.tokenFromType(TokenType.EQ),
           expression);
 
   static PostfixExpression postfixExpression(
           Expression expression, TokenType operator) =>
-      astFactory.postfixExpression(
-          expression, TokenFactory.tokenFromType(operator));
+      new PostfixExpression(expression, TokenFactory.tokenFromType(operator));
 
   static PrefixExpression prefixExpression(
           TokenType operator, Expression expression) =>
-      astFactory.prefixExpression(
-          TokenFactory.tokenFromType(operator), expression);
+      new PrefixExpression(TokenFactory.tokenFromType(operator), expression);
 
   static PropertyAccess propertyAccess(
           Expression target, SimpleIdentifier propertyName) =>
-      astFactory.propertyAccess(
+      new PropertyAccess(
           target, TokenFactory.tokenFromType(TokenType.PERIOD), propertyName);
 
   static PropertyAccess propertyAccess2(Expression target, String propertyName,
           [TokenType operator = TokenType.PERIOD]) =>
-      astFactory.propertyAccess(target, TokenFactory.tokenFromType(operator),
+      new PropertyAccess(target, TokenFactory.tokenFromType(operator),
           identifier3(propertyName));
 
   static RedirectingConstructorInvocation redirectingConstructorInvocation(
           [List<Expression> arguments]) =>
       redirectingConstructorInvocation2(null, arguments);
 
   static RedirectingConstructorInvocation redirectingConstructorInvocation2(
           String constructorName,
           [List<Expression> arguments]) =>
-      astFactory.redirectingConstructorInvocation(
+      new RedirectingConstructorInvocation(
           TokenFactory.tokenFromKeyword(Keyword.THIS),
           constructorName == null
               ? null
               : TokenFactory.tokenFromType(TokenType.PERIOD),
           constructorName == null ? null : identifier3(constructorName),
           argumentList(arguments));
 
-  static RethrowExpression rethrowExpression() => astFactory
-      .rethrowExpression(TokenFactory.tokenFromKeyword(Keyword.RETHROW));
+  static RethrowExpression rethrowExpression() =>
+      new RethrowExpression(TokenFactory.tokenFromKeyword(Keyword.RETHROW));
 
   static ReturnStatement returnStatement() => returnStatement2(null);
 
   static ReturnStatement returnStatement2(Expression expression) =>
-      astFactory.returnStatement(TokenFactory.tokenFromKeyword(Keyword.RETURN),
+      new ReturnStatement(TokenFactory.tokenFromKeyword(Keyword.RETURN),
           expression, TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ScriptTag scriptTag(String scriptTag) =>
-      astFactory.scriptTag(TokenFactory.tokenFromString(scriptTag));
+      new ScriptTag(TokenFactory.tokenFromString(scriptTag));
 
   static ShowCombinator showCombinator(List<SimpleIdentifier> identifiers) =>
-      astFactory.showCombinator(
-          TokenFactory.tokenFromString("show"), identifiers);
+      new ShowCombinator(TokenFactory.tokenFromString("show"), identifiers);
 
   static ShowCombinator showCombinator2(List<String> identifiers) =>
-      astFactory.showCombinator(
+      new ShowCombinator(
           TokenFactory.tokenFromString("show"), identifierList(identifiers));
 
   static SimpleFormalParameter simpleFormalParameter(
           Keyword keyword, String parameterName) =>
       simpleFormalParameter2(keyword, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter2(
           Keyword keyword, TypeName type, String parameterName) =>
-      astFactory.simpleFormalParameter(
+      new SimpleFormalParameter(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           identifier3(parameterName));
 
   static SimpleFormalParameter simpleFormalParameter3(String parameterName) =>
       simpleFormalParameter2(null, null, parameterName);
 
   static SimpleFormalParameter simpleFormalParameter4(
           TypeName type, String parameterName) =>
       simpleFormalParameter2(null, type, parameterName);
 
   static StringInterpolation string([List<InterpolationElement> elements]) =>
-      astFactory.stringInterpolation(elements);
+      new StringInterpolation(elements);
 
-  static SimpleStringLiteral string2(String content) => astFactory
-      .simpleStringLiteral(TokenFactory.tokenFromString("'$content'"), content);
+  static SimpleStringLiteral string2(String content) => new SimpleStringLiteral(
+      TokenFactory.tokenFromString("'$content'"), content);
 
   static SuperConstructorInvocation superConstructorInvocation(
           [List<Expression> arguments]) =>
       superConstructorInvocation2(null, arguments);
 
   static SuperConstructorInvocation superConstructorInvocation2(String name,
           [List<Expression> arguments]) =>
-      astFactory.superConstructorInvocation(
+      new SuperConstructorInvocation(
           TokenFactory.tokenFromKeyword(Keyword.SUPER),
           name == null ? null : TokenFactory.tokenFromType(TokenType.PERIOD),
           name == null ? null : identifier3(name),
           argumentList(arguments));
 
   static SuperExpression superExpression() =>
-      astFactory.superExpression(TokenFactory.tokenFromKeyword(Keyword.SUPER));
+      new SuperExpression(TokenFactory.tokenFromKeyword(Keyword.SUPER));
 
   static SwitchCase switchCase(
           Expression expression, List<Statement> statements) =>
       switchCase2(new List<Label>(), expression, statements);
 
   static SwitchCase switchCase2(List<Label> labels, Expression expression,
           List<Statement> statements) =>
-      astFactory.switchCase(labels, TokenFactory.tokenFromKeyword(Keyword.CASE),
+      new SwitchCase(labels, TokenFactory.tokenFromKeyword(Keyword.CASE),
           expression, TokenFactory.tokenFromType(TokenType.COLON), statements);
 
   static SwitchDefault switchDefault(
           List<Label> labels, List<Statement> statements) =>
-      astFactory.switchDefault(
-          labels,
-          TokenFactory.tokenFromKeyword(Keyword.DEFAULT),
-          TokenFactory.tokenFromType(TokenType.COLON),
-          statements);
+      new SwitchDefault(labels, TokenFactory.tokenFromKeyword(Keyword.DEFAULT),
+          TokenFactory.tokenFromType(TokenType.COLON), statements);
 
   static SwitchDefault switchDefault2(List<Statement> statements) =>
       switchDefault(new List<Label>(), statements);
 
   static SwitchStatement switchStatement(
           Expression expression, List<SwitchMember> members) =>
-      astFactory.switchStatement(
+      new SwitchStatement(
           TokenFactory.tokenFromKeyword(Keyword.SWITCH),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           expression,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           TokenFactory.tokenFromType(TokenType.OPEN_CURLY_BRACKET),
           members,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static SymbolLiteral symbolLiteral(List<String> components) {
     List<Token> identifierList = new List<Token>();
     for (String component in components) {
       identifierList.add(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, component));
     }
-    return astFactory.symbolLiteral(
+    return new SymbolLiteral(
         TokenFactory.tokenFromType(TokenType.HASH), identifierList);
   }
 
   static BlockFunctionBody syncBlockFunctionBody(
           [List<Statement> statements]) =>
-      astFactory.blockFunctionBody(
+      new BlockFunctionBody(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "sync"),
           null,
           block(statements));
 
   static BlockFunctionBody syncGeneratorBlockFunctionBody(
           [List<Statement> statements]) =>
-      astFactory.blockFunctionBody(
+      new BlockFunctionBody(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "sync"),
           TokenFactory.tokenFromType(TokenType.STAR),
           block(statements));
 
   static ThisExpression thisExpression() =>
-      astFactory.thisExpression(TokenFactory.tokenFromKeyword(Keyword.THIS));
+      new ThisExpression(TokenFactory.tokenFromKeyword(Keyword.THIS));
 
   static ThrowExpression throwExpression() => throwExpression2(null);
 
   static ThrowExpression throwExpression2(Expression expression) =>
-      astFactory.throwExpression(
+      new ThrowExpression(
           TokenFactory.tokenFromKeyword(Keyword.THROW), expression);
 
   static TopLevelVariableDeclaration topLevelVariableDeclaration(
           Keyword keyword,
           TypeName type,
           List<VariableDeclaration> variables) =>
-      astFactory.topLevelVariableDeclaration(
+      new TopLevelVariableDeclaration(
           null,
           null,
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static TopLevelVariableDeclaration topLevelVariableDeclaration2(
           Keyword keyword, List<VariableDeclaration> variables) =>
-      astFactory.topLevelVariableDeclaration(
+      new TopLevelVariableDeclaration(
           null,
           null,
           variableDeclarationList(keyword, null, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static TryStatement tryStatement(Block body, Block finallyClause) =>
       tryStatement3(body, new List<CatchClause>(), finallyClause);
 
   static TryStatement tryStatement2(
           Block body, List<CatchClause> catchClauses) =>
       tryStatement3(body, catchClauses, null);
 
   static TryStatement tryStatement3(
           Block body, List<CatchClause> catchClauses, Block finallyClause) =>
-      astFactory.tryStatement(
+      new TryStatement(
           TokenFactory.tokenFromKeyword(Keyword.TRY),
           body,
           catchClauses,
           finallyClause == null
               ? null
               : TokenFactory.tokenFromKeyword(Keyword.FINALLY),
           finallyClause);
 
   static FunctionTypeAlias typeAlias(TypeName returnType, String name,
           TypeParameterList typeParameters, FormalParameterList parameters) =>
-      astFactory.functionTypeAlias(
+      new FunctionTypeAlias(
           null,
           null,
           TokenFactory.tokenFromKeyword(Keyword.TYPEDEF),
           returnType,
           identifier3(name),
           typeParameters,
           parameters,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static TypeArgumentList typeArgumentList(List<TypeName> typeNames) {
     if (typeNames == null || typeNames.length == 0) {
       return null;
     }
-    return astFactory.typeArgumentList(TokenFactory.tokenFromType(TokenType.LT),
+    return new TypeArgumentList(TokenFactory.tokenFromType(TokenType.LT),
         typeNames, TokenFactory.tokenFromType(TokenType.GT));
   }
 
   /**
    * Create a type name whose name has been resolved to the given [element] and
    * whose type has been resolved to the type of the given element.
    *
    * <b>Note:</b> This method does not correctly handle class elements that have
    * type parameters.
    */
   static TypeName typeName(ClassElement element, [List<TypeName> arguments]) {
     SimpleIdentifier name = identifier3(element.name);
     name.staticElement = element;
     TypeName typeName = typeName3(name, arguments);
     typeName.type = element.type;
     return typeName;
   }
 
   static TypeName typeName3(Identifier name, [List<TypeName> arguments]) =>
-      astFactory.typeName(name, typeArgumentList(arguments));
+      new TypeName(name, typeArgumentList(arguments));
 
   static TypeName typeName4(String name, [List<TypeName> arguments]) =>
-      astFactory.typeName(identifier3(name), typeArgumentList(arguments));
+      new TypeName(identifier3(name), typeArgumentList(arguments));
 
   static TypeParameter typeParameter(String name) =>
-      astFactory.typeParameter(null, null, identifier3(name), null, null);
+      new TypeParameter(null, null, identifier3(name), null, null);
 
   static TypeParameter typeParameter2(String name, TypeName bound) =>
-      astFactory.typeParameter(null, null, identifier3(name),
+      new TypeParameter(null, null, identifier3(name),
           TokenFactory.tokenFromKeyword(Keyword.EXTENDS), bound);
 
   static TypeParameterList typeParameterList([List<String> typeNames]) {
     List<TypeParameter> typeParameters = null;
     if (typeNames != null && !typeNames.isEmpty) {
       typeParameters = new List<TypeParameter>();
       for (String typeName in typeNames) {
         typeParameters.add(typeParameter(typeName));
       }
     }
-    return astFactory.typeParameterList(
-        TokenFactory.tokenFromType(TokenType.LT),
-        typeParameters,
-        TokenFactory.tokenFromType(TokenType.GT));
+    return new TypeParameterList(TokenFactory.tokenFromType(TokenType.LT),
+        typeParameters, TokenFactory.tokenFromType(TokenType.GT));
   }
 
   static VariableDeclaration variableDeclaration(String name) =>
-      astFactory.variableDeclaration(identifier3(name), null, null);
+      new VariableDeclaration(identifier3(name), null, null);
 
   static VariableDeclaration variableDeclaration2(
           String name, Expression initializer) =>
-      astFactory.variableDeclaration(identifier3(name),
+      new VariableDeclaration(identifier3(name),
           TokenFactory.tokenFromType(TokenType.EQ), initializer);
 
   static VariableDeclarationList variableDeclarationList(Keyword keyword,
           TypeName type, List<VariableDeclaration> variables) =>
-      astFactory.variableDeclarationList(
+      new VariableDeclarationList(
           null,
           null,
           keyword == null ? null : TokenFactory.tokenFromKeyword(keyword),
           type,
           variables);
 
   static VariableDeclarationList variableDeclarationList2(
           Keyword keyword, List<VariableDeclaration> variables) =>
       variableDeclarationList(keyword, null, variables);
 
   static VariableDeclarationStatement variableDeclarationStatement(
           Keyword keyword,
           TypeName type,
           List<VariableDeclaration> variables) =>
-      astFactory.variableDeclarationStatement(
+      new VariableDeclarationStatement(
           variableDeclarationList(keyword, type, variables),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static VariableDeclarationStatement variableDeclarationStatement2(
           Keyword keyword, List<VariableDeclaration> variables) =>
       variableDeclarationStatement(keyword, null, variables);
 
   static WhileStatement whileStatement(Expression condition, Statement body) =>
-      astFactory.whileStatement(
+      new WhileStatement(
           TokenFactory.tokenFromKeyword(Keyword.WHILE),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           body);
 
   static WithClause withClause(List<TypeName> types) =>
-      astFactory.withClause(TokenFactory.tokenFromKeyword(Keyword.WITH), types);
+      new WithClause(TokenFactory.tokenFromKeyword(Keyword.WITH), types);
 
   static YieldStatement yieldEachStatement(Expression expression) =>
-      astFactory.yieldStatement(
+      new YieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           TokenFactory.tokenFromType(TokenType.STAR),
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(Expression expression) =>
-      astFactory.yieldStatement(
+      new YieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           null,
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }