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

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
+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';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisEngine;
@@ skipping 365 matching lines @@
       // Consider current keyword token as an identifier.
       // It is not always true, e.g. "^is T" where "^" is place the place for
       // synthetic identifier. By creating SyntheticStringToken we can
       // distinguish a real identifier from synthetic. In the code completion
       // behavior will depend on a cursor position - before or on "is".
       syntheticToken = _injectToken(new SyntheticStringToken(
           TokenType.IDENTIFIER, _currentToken.lexeme, _currentToken.offset));
     } else {
       syntheticToken = _createSyntheticToken(TokenType.IDENTIFIER);
     }
-    return new SimpleIdentifier(syntheticToken, isDeclaration: isDeclaration);
+    return astFactory.simpleIdentifier(syntheticToken,

[Brian Wilkerson, 2016/11/30 20:05:31]

I'm surprised by these changes. I guess I was expecting that the code would just
invoke the constructor on the implementation class directly rather than going
through the factory. I don't know that this is wrong, but the extra layer of
indirection seems unnecessary.

[Paul Berry, 2016/11/30 20:21:57]

My long term plan is to make the AST factory an injectible dependency by storing
it as a field of the Parser class.  Using the factory here paves the way for
that.

+        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
    * token and return the token that was current before this method was invoked.
    */
   Token getAndAdvance() {
     Token token = _currentToken;
     _currentToken = _currentToken.next;
     return token;
   }
@@ skipping 178 matching lines @@
    * parsed.
    *
    *     additiveExpression ::=
    *         multiplicativeExpression (additiveOperator multiplicativeExpression)*
    *       | 'super' (additiveOperator multiplicativeExpression)+
    */
   Expression parseAdditiveExpression() {
     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;
   }
 
   /**
    * Parse an annotation. Return the annotation that was parsed.
    *
    * This method assumes that the current token matches [TokenType.AT].
    *
    *     annotation ::=
    *         '@' qualified ('.' identifier)? arguments?
    */
   Annotation parseAnnotation() {
     Token atSign = getAndAdvance();
     Identifier name = parsePrefixedIdentifier();
     Token period = null;
     SimpleIdentifier constructorName = null;
     if (_matches(TokenType.PERIOD)) {
       period = getAndAdvance();
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList arguments = null;
     if (_matches(TokenType.OPEN_PAREN)) {
       arguments = parseArgumentList();
     }
-    return new Annotation(atSign, name, period, constructorName, arguments);
+    return astFactory.annotation(
+        atSign, name, period, constructorName, arguments);
   }
 
   /**
    * Parse an argument. Return the argument that was parsed.
    *
    *     argument ::=
    *         namedArgument
    *       | expression
    *
    *     namedArgument ::=
    *         label expression
    */
   Expression parseArgument() {
     // TODO(brianwilkerson) Consider returning a wrapper indicating whether the
     // expression is a named expression in order to remove the 'is' check in
     // 'parseArgumentList'.
     //
     // Both namedArgument and expression can start with an identifier, but only
     // 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();
     }
   }
 
   /**
    * Parse a list of arguments. Return the argument list that was parsed.
    *
    * This method assumes that the current token matches [TokenType.OPEN_PAREN].
    *
    *     arguments ::=
    *         '(' argumentList? ')'
    *
    *     argumentList ::=
    *         namedArgument (',' namedArgument)*
    *       | expressionList (',' namedArgument)*
    */
   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,
     // we allow them to appear in any order so that we can recover faster.
     //
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
       Expression argument = parseArgument();
       List<Expression> arguments = <Expression>[argument];
@@ skipping 17 matching lines @@
               generatedError = true;
             }
           }
         }
       }
       // Recovery: If the next token is not a right parenthesis, look at the
       // left parenthesis to see whether there is a matching right parenthesis.
       // 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;
     }
   }
 
   /**
    * Parse an assert statement. Return the assert statement.
    *
    * This method assumes that the current token matches `Keyword.ASSERT`.
    *
    *     assertStatement ::=
    *         'assert' '(' expression [',' expression] ')' ';'
    */
   AssertStatement parseAssertStatement() {
     Token keyword = getAndAdvance();
     Token leftParen = _expect(TokenType.OPEN_PAREN);
     Expression expression = parseExpression2();
     Token comma;
     Expression message;
     if (_matches(TokenType.COMMA)) {
       comma = getAndAdvance();
       message = parseExpression2();
     }
     Token rightParen = _expect(TokenType.CLOSE_PAREN);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new AssertStatement(
+    return astFactory.assertStatement(
         keyword, leftParen, expression, comma, message, rightParen, semicolon);
   }
 
   /**
    * Parse an assignable expression. The [primaryAllowed] is `true` if the
    * expression is allowed to be a primary without any assignable selector.
    * Return the assignable expression that was parsed.
    *
    *     assignableExpression ::=
    *         primary (arguments* assignableSelector)+
    *       | 'super' unconditionalAssignableSelector
    *       | identifier
    */
   Expression parseAssignableExpression(bool primaryAllowed) {
     if (_matchesKeyword(Keyword.SUPER)) {
       return parseAssignableSelector(
-          new SuperExpression(getAndAdvance()), false,
+          astFactory.superExpression(getAndAdvance()), false,
           allowConditional: false);
     }
     return _parseAssignableExpressionNotStartingWithSuper(primaryAllowed);
   }
 
   /**
    * Parse an assignable selector. The [prefix] is the expression preceding the
    * selector. The [optional] is `true` if the selector is optional. Return the
    * assignable selector that was parsed, or the original prefix if there was no
    * assignable selector.  If [allowConditional] is false, then the '?.'
@@ skipping 10 matching lines @@
   Expression parseAssignableSelector(Expression prefix, bool optional,
       {bool allowConditional: true}) {
     TokenType type = _currentToken.type;
     if (type == TokenType.OPEN_SQUARE_BRACKET) {
       Token leftBracket = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       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;
       }
     } else {
       bool isQuestionPeriod = type == TokenType.QUESTION_PERIOD;
       if (type == TokenType.PERIOD || isQuestionPeriod) {
         if (isQuestionPeriod && !allowConditional) {
           _reportErrorForCurrentToken(
               ParserErrorCode.INVALID_OPERATOR_FOR_SUPER,
               [_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) {
           // Report the missing selector.
           _reportErrorForCurrentToken(
               ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
         }
         return prefix;
       }
     }
   }
 
   /**
    * Parse a await expression. Return the await expression that was parsed.
    *
    * This method assumes that the current token matches `_AWAIT`.
    *
    *     awaitExpression ::=
    *         'await' unaryExpression
    */
   AwaitExpression parseAwaitExpression() {
     Token awaitToken = getAndAdvance();
     Expression expression = parseUnaryExpression();
-    return new AwaitExpression(awaitToken, expression);
+    return astFactory.awaitExpression(awaitToken, expression);
   }
 
   /**
    * Parse a bitwise and expression. Return the bitwise and expression that was
    * parsed.
    *
    *     bitwiseAndExpression ::=
    *         shiftExpression ('&' shiftExpression)*
    *       | 'super' ('&' shiftExpression)+
    */
   Expression parseBitwiseAndExpression() {
     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;
   }
 
   /**
    * Parse a bitwise or expression. Return the bitwise or expression that was
    * parsed.
    *
    *     bitwiseOrExpression ::=
    *         bitwiseXorExpression ('|' bitwiseXorExpression)*
    *       | 'super' ('|' bitwiseXorExpression)+
    */
   Expression parseBitwiseOrExpression() {
     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;
   }
 
   /**
    * Parse a bitwise exclusive-or expression. Return the bitwise exclusive-or
    * expression that was parsed.
    *
    *     bitwiseXorExpression ::=
    *         bitwiseAndExpression ('^' bitwiseAndExpression)*
    *       | 'super' ('^' bitwiseAndExpression)+
    */
   Expression parseBitwiseXorExpression() {
     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;
   }
 
   /**
    * Parse a block. Return the block that was parsed.
    *
    * This method assumes that the current token matches
    * [TokenType.OPEN_CURLY_BRACKET].
@@ skipping 20 matching lines @@
       } else if (statement != null) {
         statements.add(statement);
       }
       statementStart = _currentToken;
     }
     // Recovery: If the next token is not a right curly bracket, look at the
     // left curly bracket to see whether there is a matching right bracket. If
     // 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);
   }
 
   /**
    * Parse a break statement. Return the break statement that was parsed.
    *
    * This method assumes that the current token matches `Keyword.BREAK`.
    *
    *     breakStatement ::=
    *         'break' identifier? ';'
    */
   Statement parseBreakStatement() {
     Token breakKeyword = getAndAdvance();
     SimpleIdentifier label = null;
     if (_matchesIdentifier()) {
       label = _parseSimpleIdentifierUnchecked();
     }
     if (!_inLoop && !_inSwitch && label == null) {
       _reportErrorForToken(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, breakKeyword);
     }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new BreakStatement(breakKeyword, label, semicolon);
+    return astFactory.breakStatement(breakKeyword, label, semicolon);
   }
 
   /**
    * Parse a cascade section. Return the expression representing the cascaded
    * method invocation.
    *
    * This method assumes that the current token matches
    * `TokenType.PERIOD_PERIOD`.
    *
    *     cascadeSection ::=
@@ skipping 13 matching lines @@
     SimpleIdentifier functionName = null;
     if (_matchesIdentifier()) {
       functionName = _parseSimpleIdentifierUnchecked();
     } else if (_currentToken.type == TokenType.OPEN_SQUARE_BRACKET) {
       Token leftBracket = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       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 {
         _inInitializer = wasInInitializer;
       }
     } else {
       _reportErrorForToken(ParserErrorCode.MISSING_IDENTIFIER, _currentToken,
           [_currentToken.lexeme]);
       functionName = createSyntheticIdentifier();
     }
     assert((expression == null && functionName != null) ||
         (expression != null && functionName == null));
     if (_isLikelyArgumentList()) {
       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);
     bool progress = true;
     while (progress) {
       progress = false;
       Expression selector = parseAssignableSelector(expression, true);
       if (!identical(selector, expression)) {
         expression = selector;
         progress = true;
         while (_isLikelyArgumentList()) {
           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());
           }
         }
       }
     }
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
-      expression = new AssignmentExpression(
+      expression = astFactory.assignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
    * Parse a class declaration. The [commentAndMetadata] is the metadata to be
    * associated with the member. The [abstractKeyword] is the token for the
    * keyword 'abstract', or `null` if the keyword was not given. Return the
    * class declaration that was parsed.
@@ skipping 101 matching lines @@
       leftBracket = getAndAdvance();
       members = _parseClassMembers(className, _getEndToken(leftBracket));
       rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
     } else {
       // Recovery: Check for an unmatched closing curly bracket and parse
       // members until it is reached.
       leftBracket = _createSyntheticToken(TokenType.OPEN_CURLY_BRACKET);
       rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_CLASS_BODY);
     }
-    ClassDeclaration classDeclaration = new ClassDeclaration(
+    ClassDeclaration classDeclaration = astFactory.classDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         abstractKeyword,
         keyword,
         name,
         typeParameters,
         extendsClause,
         withClause,
         implementsClause,
         leftBracket,
@@ skipping 10 matching lines @@
    *
    *     classMemberDefinition ::=
    *         declaration ';'
    *       | methodSignature functionBody
    */
   ClassMember parseClassMember(String className) {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     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);
       if (keyword == Keyword.GET && isFollowedByIdentifier) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return parseGetter(commentAndMetadata, modifiers.externalKeyword,
             modifiers.staticKeyword, returnType);
       } else if (keyword == Keyword.SET && isFollowedByIdentifier) {
         _validateModifiersForGetterOrSetterOrMethod(modifiers);
         return parseSetter(commentAndMetadata, modifiers.externalKeyword,
@@ skipping 98 matching lines @@
         keyword = modifiers.finalKeyword;
       }
       if (keyword == null) {
         keyword = modifiers.constKeyword;
       }
       if (keyword != null) {
         //
         // 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<VariableDeclaration> variables = <VariableDeclaration>[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(
           ParserErrorCode.EXPECTED_CLASS_MEMBER, _currentToken);
       if (commentAndMetadata.comment != null ||
           commentAndMetadata.hasMetadata) {
         //
         // We appear to have found an incomplete declaration at the end of the
         // class. At this point it consists of a metadata, which we don't want
         // 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,
             null,
             null,
             null,
             null,
             createSyntheticIdentifier(isDeclaration: true),
             null,
-            new FormalParameterList(
+            astFactory.formalParameterList(
                 null, <FormalParameter>[], null, null, null),
-            new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
+            astFactory
+                .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
     } else if (_tokenMatches(next, TokenType.PERIOD) &&
         _tokenMatchesIdentifier(_peekAt(2)) &&
         _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
       return _parseConstructor(
           commentAndMetadata,
           modifiers.externalKeyword,
           _validateModifiersForConstructor(modifiers),
           modifiers.factoryKeyword,
           parseSimpleIdentifier(),
           getAndAdvance(),
           parseSimpleIdentifier(isDeclaration: true),
           parseFormalParameterList());
     } else if (_tokenMatches(next, TokenType.OPEN_PAREN)) {
       TypeName returnType = _parseOptionalTypeNameComment();
       SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
       if (_matches(TokenType.COLON) ||
           modifiers.factoryKeyword != null ||
           methodName.name == className) {
         return _parseConstructor(
             commentAndMetadata,
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            new SimpleIdentifier(methodName.token, isDeclaration: false),
+            astFactory.simpleIdentifier(methodName.token, isDeclaration: false),
             null,
             null,
             parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(
           commentAndMetadata,
           modifiers.externalKeyword,
           modifiers.staticKeyword,
@@ skipping 87 matching lines @@
           _parseSimpleIdentifierUnchecked(isDeclaration: true);
       TypeParameterList typeParameters = _parseGenericCommentTypeParameters();
       FormalParameterList parameters = parseFormalParameterList();
       if (methodName.name == className) {
         _reportErrorForNode(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, type);
         return _parseConstructor(
             commentAndMetadata,
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            new SimpleIdentifier(methodName.token, isDeclaration: true),
+            astFactory.simpleIdentifier(methodName.token, isDeclaration: true),
             null,
             null,
             parameters);
       }
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       _validateFormalParameterList(parameters);
       return _parseMethodDeclarationAfterParameters(
           commentAndMetadata,
           modifiers.externalKeyword,
           modifiers.staticKeyword,
@@ skipping 47 matching lines @@
   /**
    * Parse a single combinator. Return the combinator that was parsed, or `null`
    * if no combinator is found.
    *
    *     combinator ::=
    *         'show' identifier (',' identifier)*
    *       | 'hide' identifier (',' identifier)*
    */
   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;
   }
 
   /**
    * Parse a list of combinators in a directive. Return the combinators that
    * were parsed, or `null` if there are no combinators.
    *
    *     combinator ::=
    *         'show' identifier (',' identifier)*
@@ skipping 59 matching lines @@
           null, new SubSequenceReader(referenceSource, sourceOffset), listener);
       scanner.setSourceStart(1, 1);
       Token firstToken = scanner.tokenize();
       if (listener.errorReported) {
         return null;
       }
       if (firstToken.type == TokenType.EOF) {
         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)) {
         newKeyword = firstToken;
         firstToken = firstToken.next;
       }
       if (firstToken.isUserDefinableOperator) {
         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)) {
         Token secondToken = firstToken.next;
         Token thirdToken = secondToken.next;
         Token nextToken;
         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 ||
             keyword == Keyword.NULL ||
             keyword == Keyword.TRUE ||
             keyword == Keyword.FALSE) {
           // TODO(brianwilkerson) If we want to support this we will need to
           // extend the definition of CommentReference to take an expression
           // rather than an identifier. For now we just ignore it to reduce the
           // number of errors produced, but that's probably not a valid long term
@@ skipping 69 matching lines @@
               int nameEnd = StringUtilities.indexOfFirstNotLetterDigit(
                   comment, leftIndex + 1);
               String name = comment.substring(leftIndex + 1, nameEnd);
               nameToken =
                   new StringToken(TokenType.IDENTIFIER, name, nameOffset);
             } else {
               nameToken = new SyntheticStringToken(
                   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;
           }
           leftIndex = comment.indexOf('[', rightIndex);
         } else {
           leftIndex = comment.indexOf('[', range[1]);
         }
       }
     }
@@ skipping 23 matching lines @@
    *         scriptTag? topLevelElement*
    *
    *     topLevelElement ::=
    *         directive
    *       | topLevelDeclaration
    */
   CompilationUnit parseCompilationUnit2() {
     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
     // in a given order, we allow directives and declarations to occur in any
     // order so that we can recover better.
     //
     bool libraryDirectiveFound = false;
     bool partOfDirectiveFound = false;
     bool partDirectiveFound = false;
     bool directiveFoundAfterDeclaration = false;
@@ skipping 110 matching lines @@
             _reportErrorForToken(ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES,
                 directive.partKeyword);
           }
         } else {
           _reportErrorForToken(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART,
               directives[i].keyword);
         }
 //        }
       }
     }
-    return new CompilationUnit(
+    return astFactory.compilationUnit(
         firstToken, scriptTag, directives, declarations, _currentToken);
   }
 
   /**
    * Parse a compilation unit member. The [commentAndMetadata] is the metadata
    * to be associated with the member. Return the compilation unit member that
    * was parsed, or `null` if what was parsed could not be represented as a
    * compilation unit member.
    *
    *     compilationUnitMember ::=
@@ skipping 20 matching lines @@
     if (keyword == Keyword.TYPEDEF &&
         nextType != TokenType.PERIOD &&
         nextType != TokenType.LT &&
         nextType != TokenType.OPEN_PAREN) {
       _validateModifiersForTypedef(modifiers);
       return parseTypeAlias(commentAndMetadata);
     } else if (keyword == Keyword.ENUM) {
       _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) &&
           _tokenMatchesIdentifier(next)) {
         _validateModifiersForTopLevelFunction(modifiers);
         return parseFunctionDeclaration(
             commentAndMetadata, modifiers.externalKeyword, returnType);
       } else if (keyword == Keyword.OPERATOR && _isOperator(next)) {
         _reportErrorForToken(ParserErrorCode.TOP_LEVEL_OPERATOR, _currentToken);
         return _convertToFunctionDeclaration(_parseOperatorAfterKeyword(
@@ skipping 18 matching lines @@
         if (_matchesIdentifier()) {
           if (next.matchesAny(const <TokenType>[
             TokenType.EQ,
             TokenType.COMMA,
             TokenType.SEMICOLON
           ])) {
             //
             // 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,
                     _validateModifiersForTopLevelVariable(modifiers), null),
                 _expect(TokenType.SEMICOLON));
           }
         }
         _reportErrorForToken(
             ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken);
         return null;
@@ skipping 16 matching lines @@
         keyword = modifiers.finalKeyword;
       }
       if (keyword == null) {
         keyword = modifiers.constKeyword;
       }
       if (keyword != null) {
         //
         // 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<VariableDeclaration> variables = <VariableDeclaration>[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);
       return null;
     } else if (_isPeekGenericTypeParametersAndOpenParen()) {
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, null);
     } else if (_tokenMatches(next, TokenType.OPEN_PAREN)) {
       TypeName returnType = _parseOptionalTypeNameComment();
       _validateModifiersForTopLevelFunction(modifiers);
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, returnType);
     } else if (next.matchesAny(const <TokenType>[
       TokenType.EQ,
       TokenType.COMMA,
       TokenType.SEMICOLON
     ])) {
       if (modifiers.constKeyword == null &&
           modifiers.finalKeyword == null &&
           modifiers.varKeyword == null) {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
-      return new TopLevelVariableDeclaration(
+      return astFactory.topLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           parseVariableDeclarationListAfterType(
               null, _validateModifiersForTopLevelVariable(modifiers), null),
           _expect(TokenType.SEMICOLON));
     }
     TypeName returnType = parseReturnType();
     keyword = _currentToken.keyword;
     next = _peek();
     if ((keyword == Keyword.GET || keyword == Keyword.SET) &&
         _tokenMatchesIdentifier(next)) {
       _validateModifiersForTopLevelFunction(modifiers);
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, returnType);
     } else if (keyword == Keyword.OPERATOR && _isOperator(next)) {
       _reportErrorForToken(ParserErrorCode.TOP_LEVEL_OPERATOR, _currentToken);
       return _convertToFunctionDeclaration(_parseOperatorAfterKeyword(
           commentAndMetadata,
           modifiers.externalKeyword,
           returnType,
           getAndAdvance()));
     } else if (_matches(TokenType.AT)) {
-      return new TopLevelVariableDeclaration(
+      return astFactory.topLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           parseVariableDeclarationListAfterType(null,
               _validateModifiersForTopLevelVariable(modifiers), returnType),
           _expect(TokenType.SEMICOLON));
     } else if (!_matchesIdentifier()) {
       // TODO(brianwilkerson) Generalize this error. We could also be parsing a
       // top-level variable at this point.
       _reportErrorForToken(ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken);
       Token semicolon;
       if (_matches(TokenType.SEMICOLON)) {
         semicolon = getAndAdvance();
       } else {
         semicolon = _createSyntheticToken(TokenType.SEMICOLON);
       }
-      VariableDeclaration variable =
-          new VariableDeclaration(createSyntheticIdentifier(), null, null);
+      VariableDeclaration variable = astFactory.variableDeclaration(
+          createSyntheticIdentifier(), null, null);
       List<VariableDeclaration> variables = <VariableDeclaration>[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>[
       TokenType.OPEN_PAREN,
       TokenType.FUNCTION,
       TokenType.OPEN_CURLY_BRACKET,
       TokenType.LT
     ])) {
       _validateModifiersForTopLevelFunction(modifiers);
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, returnType);
     }
-    return new TopLevelVariableDeclaration(
+    return astFactory.topLevelVariableDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         parseVariableDeclarationListAfterType(
             null, _validateModifiersForTopLevelVariable(modifiers), returnType),
         _expect(TokenType.SEMICOLON));
   }
 
   /**
    * Parse a conditional expression. Return the conditional expression that was
    * parsed.
    *
    *     conditionalExpression ::=
    *         ifNullExpression ('?' expressionWithoutCascade ':' expressionWithoutCascade)?
    */
   Expression parseConditionalExpression() {
     Expression condition = parseIfNullExpression();
     if (_currentToken.type != TokenType.QUESTION) {
       return condition;
     }
     Token question = getAndAdvance();
     Expression thenExpression = parseExpressionWithoutCascade();
     Token colon = _expect(TokenType.COLON);
     Expression elseExpression = parseExpressionWithoutCascade();
-    return new ConditionalExpression(
+    return astFactory.conditionalExpression(
         condition, question, thenExpression, colon, elseExpression);
   }
 
   /**
    * Parse a configuration in either an import or export directive.
    *
    * This method assumes that the current token matches `Keyword.IF`.
    *
    *     configuration ::=
    *         'if' '(' test ')' uri
@@ skipping 13 matching lines @@
     if (_matches(TokenType.EQ_EQ)) {
       equalToken = getAndAdvance();
       value = parseStringLiteral();
       if (value is StringInterpolation) {
         _reportErrorForNode(
             ParserErrorCode.INVALID_LITERAL_IN_CONFIGURATION, value);
       }
     }
     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);
   }
 
   /**
    * Parse a const expression. Return the const expression that was parsed.
    *
    * This method assumes that the current token matches `Keyword.CONST`.
    *
    *     constExpression ::=
    *         instanceCreationExpression
    *       | listLiteral
@@ skipping 36 matching lines @@
     } else {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER);
       Keyword keyword = _currentToken.keyword;
       if (keyword != Keyword.THIS &&
           keyword != Keyword.SUPER &&
           type != TokenType.OPEN_CURLY_BRACKET &&
           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;
     _inInitializer = true;
     try {
       Expression expression = parseConditionalExpression();
       if (_matches(TokenType.PERIOD_PERIOD)) {
         List<Expression> cascadeSections = <Expression>[];
         do {
           Expression section = parseCascadeSection();
           if (section != null) {
             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;
     }
   }
 
   /**
    * Parse the name of a constructor. Return the constructor name that was
    * parsed.
    *
    *     constructorName:
    *         type ('.' identifier)?
    */
   ConstructorName parseConstructorName() {
     TypeName type = parseTypeName(false);
     Token period = null;
     SimpleIdentifier name = null;
     if (_matches(TokenType.PERIOD)) {
       period = getAndAdvance();
       name = parseSimpleIdentifier();
     }
-    return new ConstructorName(type, period, name);
+    return astFactory.constructorName(type, period, name);
   }
 
   /**
    * Parse a continue statement. Return the continue statement that was parsed.
    *
    * This method assumes that the current token matches `Keyword.CONTINUE`.
    *
    *     continueStatement ::=
    *         'continue' identifier? ';'
    */
   Statement parseContinueStatement() {
     Token continueKeyword = getAndAdvance();
     if (!_inLoop && !_inSwitch) {
       _reportErrorForToken(
           ParserErrorCode.CONTINUE_OUTSIDE_OF_LOOP, continueKeyword);
     }
     SimpleIdentifier label = null;
     if (_matchesIdentifier()) {
       label = _parseSimpleIdentifierUnchecked();
     }
     if (_inSwitch && !_inLoop && label == null) {
       _reportErrorForToken(
           ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE, continueKeyword);
     }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ContinueStatement(continueKeyword, label, semicolon);
+    return astFactory.continueStatement(continueKeyword, label, semicolon);
   }
 
   /**
    * Parse a directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the directive that was parsed.
    *
    *     directive ::=
    *         exportDirective
    *       | libraryDirective
    *       | importDirective
@@ skipping 32 matching lines @@
    * Parse the script tag and directives in a compilation unit until the first
    * non-directive is encountered. Return the compilation unit that was parsed.
    *
    *     compilationUnit ::=
    *         scriptTag? directive*
    */
   CompilationUnit parseDirectives2() {
     Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (_matches(TokenType.SCRIPT_TAG)) {
-      scriptTag = new ScriptTag(getAndAdvance());
+      scriptTag = astFactory.scriptTag(getAndAdvance());
     }
     List<Directive> directives = <Directive>[];
     while (!_matches(TokenType.EOF)) {
       CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
       Keyword keyword = _currentToken.keyword;
       TokenType type = _peek().type;
       if ((keyword == Keyword.IMPORT ||
               keyword == Keyword.EXPORT ||
               keyword == Keyword.LIBRARY ||
               keyword == Keyword.PART) &&
           type != TokenType.PERIOD &&
           type != TokenType.LT &&
           type != TokenType.OPEN_PAREN) {
         directives.add(parseDirective(commentAndMetadata));
       } else if (_matches(TokenType.SEMICOLON)) {
         _advance();
       } else {
         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);
   }
 
   /**
    * Parse a documentation comment based on the given list of documentation
    * comment tokens. Return the documentation comment that was parsed, or `null`
    * if there was no comment.
    *
    *     documentationComment ::=
    *         multiLineComment?
    *       | singleLineComment*
    */
   Comment parseDocumentationComment(List<DocumentationCommentToken> tokens) {
     if (tokens == null) {
       return null;
     }
     List<CommentReference> references = parseCommentReferences(tokens);
-    return Comment.createDocumentationCommentWithReferences(tokens, references);
+    return astFactory.documentationComment(tokens, references);
   }
 
   /**
    * Parse a documentation comment. Return the documentation comment that was
    * parsed, or `null` if there was no comment.
    *
    *     documentationComment ::=
    *         multiLineComment?
    *       | singleLineComment*
    */
@@ skipping 30 matching lines @@
     bool wasInLoop = _inLoop;
     _inLoop = true;
     try {
       Token doKeyword = getAndAdvance();
       Statement body = parseStatement2();
       Token whileKeyword = _expectKeyword(Keyword.WHILE);
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       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;
     }
   }
 
   /**
    * Parse a dotted name. Return the dotted name that was parsed.
    *
    *     dottedName ::=
    *         identifier ('.' identifier)*
    */
   DottedName parseDottedName() {
     List<SimpleIdentifier> components = <SimpleIdentifier>[
       parseSimpleIdentifier()
     ];
     while (_optional(TokenType.PERIOD)) {
       components.add(parseSimpleIdentifier());
     }
-    return new DottedName(components);
+    return astFactory.dottedName(components);
   }
 
   /**
    * Parse an empty statement. Return the empty statement that was parsed.
    *
    * This method assumes that the current token matches `TokenType.SEMICOLON`.
    *
    *     emptyStatement ::=
    *         ';'
    */
-  Statement parseEmptyStatement() => new EmptyStatement(getAndAdvance());
+  Statement parseEmptyStatement() => astFactory.emptyStatement(getAndAdvance());
 
   /**
    * Parse an enum declaration. The [commentAndMetadata] is the metadata to be
    * associated with the member. Return the enum declaration that was parsed.
    *
    * This method assumes that the current token matches `Keyword.ENUM`.
    *
    *     enumType ::=
    *         metadata 'enum' id '{' id (',' id)* (',')? '}'
    */
@@ skipping 20 matching lines @@
           break;
         }
         constants.add(_parseEnumConstantDeclaration());
       }
       rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
     } else {
       leftBracket = _createSyntheticToken(TokenType.OPEN_CURLY_BRACKET);
       rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_ENUM_BODY);
     }
-    return new EnumDeclaration(
+    return astFactory.enumDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         keyword,
         name,
         leftBracket,
         constants,
         rightBracket);
   }
 
   /**
    * Parse an equality expression. Return the equality expression that was
    * parsed.
    *
    *     equalityExpression ::=
    *         relationalExpression (equalityOperator relationalExpression)?
    *       | 'super' equalityOperator relationalExpression
    */
   Expression parseEqualityExpression() {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isEqualityOperator) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseRelationalExpression();
     }
     bool leftEqualityExpression = false;
     while (_currentToken.type.isEqualityOperator) {
       if (leftEqualityExpression) {
         _reportErrorForNode(
             ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, expression);
       }
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseRelationalExpression());
       leftEqualityExpression = true;
     }
     return expression;
   }
 
   /**
    * Parse an export directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the export directive that was parsed.
    *
    * This method assumes that the current token matches `Keyword.EXPORT`.
    *
    *     exportDirective ::=
    *         metadata 'export' stringLiteral configuration* combinator*';'
    */
   ExportDirective parseExportDirective(CommentAndMetadata commentAndMetadata) {
     Token exportKeyword = getAndAdvance();
     StringLiteral libraryUri = _parseUri();
     List<Configuration> configurations = _parseConfigurations();
     List<Combinator> combinators = parseCombinators();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ExportDirective(
+    return astFactory.exportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         exportKeyword,
         libraryUri,
         configurations,
         combinators,
         semicolon);
   }
 
   /**
@@ skipping 32 matching lines @@
     Expression expression = parseConditionalExpression();
     TokenType type = _currentToken.type;
     if (type == TokenType.PERIOD_PERIOD) {
       List<Expression> cascadeSections = <Expression>[];
       do {
         Expression section = parseCascadeSection();
         if (section != null) {
           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;
   }
 
   /**
    * Parse a list of expressions. Return the expression that was parsed.
    *
    *     expressionList ::=
    *         expression (',' expression)*
    */
@@ skipping 23 matching lines @@
     //
     // assignableExpression is a subset of conditionalExpression, so we can
     // parse a conditional expression and then determine whether it is followed
     // by an assignmentOperator, checking for conformance to the restricted
     // grammar after making that determination.
     //
     Expression expression = parseConditionalExpression();
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
-      expression = new AssignmentExpression(
+      expression = astFactory.assignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
    * Parse a class extends clause. Return the class extends clause that was
    * parsed.
    *
    * This method assumes that the current token matches `Keyword.EXTENDS`.
    *
    *     classExtendsClause ::=
    *         'extends' type
    */
   ExtendsClause parseExtendsClause() {
     Token keyword = getAndAdvance();
     TypeName superclass = parseTypeName(false);
     _mustNotBeNullable(superclass, ParserErrorCode.NULLABLE_TYPE_IN_EXTENDS);
-    return new ExtendsClause(keyword, superclass);
+    return astFactory.extendsClause(keyword, superclass);
   }
 
   /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration.
    * The [optional] is `true` if the keyword and type are optional. Return the
    * 'final', 'const', 'var' or type that was parsed.
    *
    *     finalConstVarOrType ::=
    *         'final' type?
    *       | 'const' type?
@@ skipping 50 matching lines @@
     NormalFormalParameter parameter = parseNormalFormalParameter();
     TokenType type = _currentToken.type;
     if (type == TokenType.EQ) {
       Token separator = getAndAdvance();
       Expression defaultValue = parseExpression2();
       if (kind == ParameterKind.REQUIRED) {
         _reportErrorForNode(
             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();
       Expression defaultValue = parseExpression2();
       if (kind == ParameterKind.POSITIONAL) {
         _reportErrorForToken(
             ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
             separator);
       } else if (kind == ParameterKind.REQUIRED) {
         _reportErrorForNode(
             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;
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    *     formalParameterList ::=
    *         '(' ')'
@@ skipping 52 matching lines @@
       Token forKeyword = _expectKeyword(Keyword.FOR);
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       VariableDeclarationList variableList = null;
       Expression initialization = null;
       if (!_matches(TokenType.SEMICOLON)) {
         CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
         if (_matchesIdentifier() &&
             (_tokenMatchesKeyword(_peek(), Keyword.IN) ||
                 _tokenMatches(_peek(), TokenType.COLON))) {
           SimpleIdentifier variableName = _parseSimpleIdentifierUnchecked();
-          variableList = new VariableDeclarationList(commentAndMetadata.comment,
-              commentAndMetadata.metadata, null, null, <VariableDeclaration>[
-            new VariableDeclaration(variableName, null, null)
+          variableList = astFactory.variableDeclarationList(
+              commentAndMetadata.comment,
+              commentAndMetadata.metadata,
+              null,
+              null, <VariableDeclaration>[
+            astFactory.variableDeclaration(variableName, null, null)
           ]);
         } else if (isInitializedVariableDeclaration()) {
           variableList =
               parseVariableDeclarationListAfterMetadata(commentAndMetadata);
         } else {
           initialization = parseExpression2();
         }
         TokenType type = _currentToken.type;
         if (_matchesKeyword(Keyword.IN) || type == TokenType.COLON) {
           if (type == TokenType.COLON) {
@@ skipping 13 matching lines @@
                   [variables.length.toString()]);
             }
             VariableDeclaration variable = variables[0];
             if (variable.initializer != null) {
               _reportErrorForCurrentToken(
                   ParserErrorCode.INITIALIZED_VARIABLE_IN_FOR_EACH);
             }
             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) {
                 // TODO(jwren) metadata isn't allowed before the identifier in
                 // "identifier in expression", add warning if commentAndMetadata
                 // has content
               }
               identifier = variable.name;
             }
           }
           Token inKeyword = getAndAdvance();
           Expression iterator = parseExpression2();
           Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
           Statement body = parseStatement2();
           if (loopVariable == null) {
-            return new ForEachStatement.withReference(
+            return astFactory.forEachStatementWithReference(
                 awaitKeyword,
                 forKeyword,
                 leftParenthesis,
                 identifier,
                 inKeyword,
                 iterator,
                 rightParenthesis,
                 body);
           }
-          return new ForEachStatement.withDeclaration(
+          return astFactory.forEachStatementWithDeclaration(
               awaitKeyword,
               forKeyword,
               leftParenthesis,
               loopVariable,
               inKeyword,
               iterator,
               rightParenthesis,
               body);
         }
       }
       if (awaitKeyword != null) {
         _reportErrorForToken(
             ParserErrorCode.INVALID_AWAIT_IN_FOR, awaitKeyword);
       }
       Token leftSeparator = _expect(TokenType.SEMICOLON);
       Expression condition = null;
       if (!_matches(TokenType.SEMICOLON)) {
         condition = parseExpression2();
       }
       Token rightSeparator = _expect(TokenType.SEMICOLON);
       List<Expression> updaters = null;
       if (!_matches(TokenType.CLOSE_PAREN)) {
         updaters = parseExpressionList();
       }
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       Statement body = parseStatement2();
-      return new ForStatement(
+      return astFactory.forStatement(
           forKeyword,
           leftParenthesis,
           variableList,
           initialization,
           leftSeparator,
           condition,
           rightSeparator,
           updaters,
           rightParenthesis,
           body);
@@ skipping 26 matching lines @@
     _inAsync = false;
     _inGenerator = false;
     _inLoop = false;
     _inSwitch = false;
     try {
       TokenType type = _currentToken.type;
       if (type == TokenType.SEMICOLON) {
         if (!mayBeEmpty) {
           _reportErrorForCurrentToken(emptyErrorCode);
         }
-        return new EmptyFunctionBody(getAndAdvance());
+        return astFactory.emptyFunctionBody(getAndAdvance());
       }
       Token keyword = null;
       Token star = null;
       bool foundAsync = false;
       bool foundSync = false;
       if (type == TokenType.IDENTIFIER) {
         String lexeme = _currentToken.lexeme;
         if (lexeme == ASYNC) {
           foundAsync = true;
           keyword = getAndAdvance();
@@ skipping 28 matching lines @@
           _reportErrorForToken(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken,
               [_currentToken.lexeme]);
           _advance();
         }
         Expression expression = parseExpression2();
         Token semicolon = null;
         if (!inExpression) {
           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) {
           if (foundSync && star == null) {
             _reportErrorForToken(
                 ParserErrorCode.MISSING_STAR_AFTER_SYNC, keyword);
           }
         }
         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;
       _inGenerator = wasInGenerator;
       _inLoop = wasInLoop;
       _inSwitch = wasInSwitch;
     }
   }
 
   /**
@@ skipping 17 matching lines @@
     bool isGetter = false;
     Keyword keyword = _currentToken.keyword;
     SimpleIdentifier name = null;
     if (keyword == Keyword.GET) {
       keywordToken = getAndAdvance();
       isGetter = true;
     } else if (keyword == Keyword.SET) {
       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 {
       name = parseSimpleIdentifier(isDeclaration: true);
     }
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters = null;
     if (!isGetter) {
       if (_matches(TokenType.OPEN_PAREN)) {
         parameters = _parseFormalParameterListUnchecked();
         _validateFormalParameterList(parameters);
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
-        parameters = new FormalParameterList(
+        parameters = astFactory.formalParameterList(
             _createSyntheticToken(TokenType.OPEN_PAREN),
             null,
             null,
             null,
             _createSyntheticToken(TokenType.CLOSE_PAREN));
       }
     } else if (_matches(TokenType.OPEN_PAREN)) {
       _reportErrorForCurrentToken(ParserErrorCode.GETTER_WITH_PARAMETERS);
       _parseFormalParameterListUnchecked();
     }
     FunctionBody body;
     if (externalKeyword == null) {
       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));
   }
 
   /**
    * Parse a function declaration statement. Return the function declaration
    * statement that was parsed.
    *
    *     functionDeclarationStatement ::=
    *         functionSignature functionBody
    */
   Statement parseFunctionDeclarationStatement() {
     Modifiers modifiers = parseModifiers();
     _validateModifiersForFunctionDeclarationStatement(modifiers);
     return _parseFunctionDeclarationStatementAfterReturnType(
         parseCommentAndMetadata(), _parseOptionalReturnType());
   }
 
   /**
    * Parse a function expression. Return the function expression that was
    * parsed.
    *
    *     functionExpression ::=
    *         typeParameters? formalParameterList functionExpressionBody
    */
   FunctionExpression parseFunctionExpression() {
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
-    return new FunctionExpression(typeParameters, parameters, body);
+    return astFactory.functionExpression(typeParameters, parameters, body);
   }
 
   /**
    * Parse a getter. The [commentAndMetadata] is the documentation comment and
    * metadata to be associated with the declaration. The externalKeyword] is the
    * 'external' token. The staticKeyword] is the static keyword, or `null` if
    * the getter is not static. The [returnType] the return type that has already
    * been parsed, or `null` if there was no return type. Return the getter that
    * was parsed.
    *
@@ skipping 15 matching lines @@
       _advance();
       _advance();
     }
     FunctionBody body = parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_GETTER_WITHOUT_BODY,
         false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_GETTER_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         staticKeyword,
         returnType,
         propertyKeyword,
         null,
         name,
         null,
         null,
@@ skipping 19 matching lines @@
 
   /**
    * Parse an if-null expression.  Return the if-null expression that was
    * parsed.
    *
    *     ifNullExpression ::= logicalOrExpression ('??' logicalOrExpression)*
    */
   Expression parseIfNullExpression() {
     Expression expression = parseLogicalOrExpression();
     while (_currentToken.type == TokenType.QUESTION_QUESTION) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseLogicalOrExpression());
     }
     return expression;
   }
 
   /**
    * Parse an if statement. Return the if statement that was parsed.
    *
    * This method assumes that the current token matches `Keyword.IF`.
    *
    *     ifStatement ::=
    *         'if' '(' expression ')' statement ('else' statement)?
    */
   Statement parseIfStatement() {
     Token ifKeyword = getAndAdvance();
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     Expression condition = parseExpression2();
     Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
     Statement thenStatement = parseStatement2();
     Token elseKeyword = null;
     Statement elseStatement = null;
     if (_matchesKeyword(Keyword.ELSE)) {
       elseKeyword = getAndAdvance();
       elseStatement = parseStatement2();
     }
-    return new IfStatement(ifKeyword, leftParenthesis, condition,
+    return astFactory.ifStatement(ifKeyword, leftParenthesis, condition,
         rightParenthesis, thenStatement, elseKeyword, elseStatement);
   }
 
   /**
    * Parse an implements clause. Return the implements clause that was parsed.
    *
    * This method assumes that the current token matches `Keyword.IMPLEMENTS`.
    *
    *     implementsClause ::=
    *         'implements' type (',' type)*
    */
   ImplementsClause parseImplementsClause() {
     Token keyword = getAndAdvance();
     List<TypeName> interfaces = <TypeName>[];
     do {
       TypeName typeName = parseTypeName(false);
       _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_IMPLEMENTS);
       interfaces.add(typeName);
     } while (_optional(TokenType.COMMA));
-    return new ImplementsClause(keyword, interfaces);
+    return astFactory.implementsClause(keyword, interfaces);
   }
 
   /**
    * Parse an import directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the import directive that was parsed.
    *
    * This method assumes that the current token matches `Keyword.IMPORT`.
    *
    *     importDirective ::=
    *         metadata 'import' stringLiteral configuration* (deferred)? ('as' identifier)? combinator*';'
@@ skipping 25 matching lines @@
             ParserErrorCode.UNEXPECTED_TOKEN, [_currentToken]);
         _advance();
         if (_matchesKeyword(Keyword.AS)) {
           asToken = getAndAdvance();
           prefix = parseSimpleIdentifier(isDeclaration: true);
         }
       }
     }
     List<Combinator> combinators = parseCombinators();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ImportDirective(
+    return astFactory.importDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         importKeyword,
         libraryUri,
         configurations,
         deferredToken,
         asToken,
         prefix,
         combinators,
         semicolon);
@@ skipping 18 matching lines @@
    *     initializedIdentifier ::=
    *         identifier ('=' expression)?
    */
   FieldDeclaration parseInitializedIdentifierList(
       CommentAndMetadata commentAndMetadata,
       Token staticKeyword,
       Token keyword,
       TypeName type) {
     VariableDeclarationList fieldList =
         parseVariableDeclarationListAfterType(null, keyword, type);
-    return new FieldDeclaration(
+    return astFactory.fieldDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         staticKeyword,
         fieldList,
         _expect(TokenType.SEMICOLON));
   }
 
   /**
    * Parse an instance creation expression. The [keyword] is the 'new' or
    * 'const' keyword that introduces the expression. Return the instance
    * creation expression that was parsed.
    *
    *     instanceCreationExpression ::=
    *         ('new' | 'const') type ('.' identifier)? argumentList
    */
   InstanceCreationExpression parseInstanceCreationExpression(Token keyword) {
     ConstructorName constructorName = parseConstructorName();
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new InstanceCreationExpression(
+    return astFactory.instanceCreationExpression(
         keyword, constructorName, argumentList);
   }
 
   /**
    * Parse a label. Return the label that was parsed.
    *
    * This method assumes that the current token matches an identifier and that
    * the following token matches `TokenType.COLON`.
    *
    *     label ::=
    *         identifier ':'
    */
   Label parseLabel({bool isDeclaration: false}) {
     SimpleIdentifier label =
         _parseSimpleIdentifierUnchecked(isDeclaration: isDeclaration);
     Token colon = getAndAdvance();
-    return new Label(label, colon);
+    return astFactory.label(label, colon);
   }
 
   /**
    * Parse a library directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the library directive that was
    * parsed.
    *
    * This method assumes that the current token matches `Keyword.LIBRARY`.
    *
    *     libraryDirective ::=
    *         metadata 'library' identifier ';'
    */
   LibraryDirective parseLibraryDirective(
       CommentAndMetadata commentAndMetadata) {
     Token keyword = getAndAdvance();
     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);
   }
 
   /**
    * Parse a library identifier. Return the library identifier that was parsed.
    *
    *     libraryIdentifier ::=
    *         identifier ('.' identifier)*
    */
   LibraryIdentifier parseLibraryIdentifier() {
     List<SimpleIdentifier> components = <SimpleIdentifier>[];
     components.add(parseSimpleIdentifier());
     while (_optional(TokenType.PERIOD)) {
       components.add(parseSimpleIdentifier());
     }
-    return new LibraryIdentifier(components);
+    return astFactory.libraryIdentifier(components);
   }
 
   /**
    * Parse a list literal. The [modifier] is the 'const' modifier appearing
    * before the literal, or `null` if there is no modifier. The [typeArguments]
    * is the type arguments appearing before the literal, or `null` if there are
    * no type arguments. Return the list literal that was parsed.
    *
    * This method assumes that the current token matches either
    * `TokenType.OPEN_SQUARE_BRACKET` or `TokenType.INDEX`.
    *
    *     listLiteral ::=
    *         'const'? typeArguments? '[' (expressionList ','?)? ']'
    */
   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;
     _inInitializer = false;
     try {
       List<Expression> elements = <Expression>[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;
     }
   }
 
   /**
    * Parse a list or map literal. The [modifier] is the 'const' modifier
    * appearing before the literal, or `null` if there is no modifier. Return the
    * list or map literal that was parsed.
    *
    *     listOrMapLiteral ::=
    *         listLiteral
    *       | mapLiteral
    */
   TypedLiteral parseListOrMapLiteral(Token modifier) {
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
     if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       return parseMapLiteral(modifier, typeArguments);
     } else if (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
         _matches(TokenType.INDEX)) {
       return parseListLiteral(modifier, typeArguments);
     }
     _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL);
-    return new ListLiteral(
+    return astFactory.listLiteral(
         modifier,
         typeArguments,
         _createSyntheticToken(TokenType.OPEN_SQUARE_BRACKET),
         null,
         _createSyntheticToken(TokenType.CLOSE_SQUARE_BRACKET));
   }
 
   /**
    * Parse a logical and expression. Return the logical and expression that was
    * parsed.
    *
    *     logicalAndExpression ::=
    *         equalityExpression ('&&' equalityExpression)*
    */
   Expression parseLogicalAndExpression() {
     Expression expression = parseEqualityExpression();
     while (_currentToken.type == TokenType.AMPERSAND_AMPERSAND) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseEqualityExpression());
     }
     return expression;
   }
 
   /**
    * Parse a logical or expression. Return the logical or expression that was
    * parsed.
    *
    *     logicalOrExpression ::=
    *         logicalAndExpression ('||' logicalAndExpression)*
    */
   Expression parseLogicalOrExpression() {
     Expression expression = parseLogicalAndExpression();
     while (_currentToken.type == TokenType.BAR_BAR) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseLogicalAndExpression());
     }
     return expression;
   }
 
   /**
    * Parse a map literal. The [modifier] is the 'const' modifier appearing
    * before the literal, or `null` if there is no modifier. The [typeArguments]
    * is the type arguments that were declared, or `null` if there are no type
    * arguments. Return the map literal that was parsed.
    *
    * This method assumes that the current token matches
    * `TokenType.OPEN_CURLY_BRACKET`.
    *
    *     mapLiteral ::=
    *         'const'? typeArguments? '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
    */
   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;
     _inInitializer = false;
     try {
       List<MapLiteralEntry> entries = <MapLiteralEntry>[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;
     }
   }
 
   /**
    * Parse a map literal entry. Return the map literal entry that was parsed.
    *
    *     mapLiteralEntry ::=
    *         expression ':' expression
    */
   MapLiteralEntry parseMapLiteralEntry() {
     Expression key = parseExpression2();
     Token separator = _expect(TokenType.COLON);
     Expression value = parseExpression2();
-    return new MapLiteralEntry(key, separator, value);
+    return astFactory.mapLiteralEntry(key, separator, value);
   }
 
   /**
    * Parse the modifiers preceding a declaration. This method allows the
    * modifiers to appear in any order but does generate errors for duplicated
    * modifiers. Checks for other problems, such as having the modifiers appear
    * in the wrong order or specifying both 'const' and 'final', are reported in
    * one of the methods whose name is prefixed with `validateModifiersFor`.
    * Return the modifiers that were parsed.
    *
@@ skipping 79 matching lines @@
    * that was parsed.
    *
    *     multiplicativeExpression ::=
    *         unaryExpression (multiplicativeOperator unaryExpression)*
    *       | 'super' (multiplicativeOperator unaryExpression)+
    */
   Expression parseMultiplicativeExpression() {
     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;
   }
 
   /**
    * Parse a new expression. Return the new expression that was parsed.
    *
    * This method assumes that the current token matches `Keyword.NEW`.
    *
@@ skipping 24 matching lines @@
    *       | functionSignature functionBody
    */
   Statement parseNonLabeledStatement() {
     // TODO(brianwilkerson) Pass the comment and metadata on where appropriate.
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     TokenType type = _currentToken.type;
     if (type == TokenType.OPEN_CURLY_BRACKET) {
       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));
         }
       }
       return parseBlock();
     } else if (type == TokenType.KEYWORD &&
         !_currentToken.keyword.isPseudoKeyword) {
       Keyword keyword = _currentToken.keyword;
       // TODO(jwren) compute some metrics to figure out a better order for this
       // if-then sequence to optimize performance
       if (keyword == Keyword.ASSERT) {
         return parseAssertStatement();
       } else if (keyword == Keyword.BREAK) {
         return parseBreakStatement();
       } else if (keyword == Keyword.CONTINUE) {
         return parseContinueStatement();
       } else if (keyword == Keyword.DO) {
         return parseDoStatement();
       } else if (keyword == Keyword.FOR) {
         return parseForStatement();
       } 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();
       } else if (keyword == Keyword.WHILE) {
         return parseWhileStatement();
       } else if (keyword == Keyword.VAR || keyword == Keyword.FINAL) {
         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 <TokenType>[
               TokenType.OPEN_PAREN,
               TokenType.OPEN_CURLY_BRACKET,
               TokenType.FUNCTION,
               TokenType.LT
             ])) {
           return _parseFunctionDeclarationStatementAfterReturnType(
               commentAndMetadata, returnType);
@@ skipping 17 matching lines @@
           } else if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
             //
             // We appear to have found an incomplete statement at the end of a
             // block. Parse it as a variable declaration.
             //
             return _parseVariableDeclarationStatementAfterType(
                 commentAndMetadata, null, returnType);
           }
           _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;
         if (next.matchesAny(const <TokenType>[
           TokenType.LT,
           TokenType.OPEN_CURLY_BRACKET,
           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);
           if (afterType != null) {
             if (_tokenMatches(afterType, TokenType.OPEN_PAREN) ||
                 (_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));
             }
           }
         }
         return parseVariableDeclarationStatementAfterMetadata(
             commentAndMetadata);
       } else if (keyword == Keyword.NEW ||
           keyword == Keyword.TRUE ||
           keyword == Keyword.FALSE ||
           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();
     } else if (_inAsync && _matchesString(_AWAIT)) {
       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)) {
       Token awaitToken = _currentToken;
       Statement statement = parseForStatement();
       if (statement is! ForStatement) {
         _reportErrorForToken(
             CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT, awaitToken);
       }
       return statement;
     } else if (type == TokenType.SEMICOLON) {
       return parseEmptyStatement();
     } else if (isInitializedVariableDeclaration()) {
       return parseVariableDeclarationStatementAfterMetadata(commentAndMetadata);
     } else if (isFunctionDeclaration()) {
       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));
     }
   }
 
   /**
    * Parse a normal formal parameter. Return the normal formal parameter that
    * was parsed.
    *
    *     normalFormalParameter ::=
    *         functionSignature
@@ skipping 25 matching lines @@
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR, holder.keyword);
         }
         Token question = null;
         if (enableNnbd && _matches(TokenType.QUESTION)) {
           question = getAndAdvance();
         }
-        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,
             holder.type,
             thisKeyword,
             period,
             identifier,
             typeParameters,
             parameters);
       }
     } else if (typeParameters != null) {
       // TODO(brianwilkerson) Report an error. It looks like a function-typed
       // parameter with no parameter list.
       //_reportErrorForToken(ParserErrorCode.MISSING_PARAMETERS, typeParameters.endToken);
     }
     TypeName type = holder.type;
     if (type != null) {
       if (_tokenMatchesKeyword(type.name.beginToken, Keyword.VOID)) {
         _reportErrorForToken(
             ParserErrorCode.VOID_PARAMETER, type.name.beginToken);
       } else if (holder.keyword != null &&
           _tokenMatchesKeyword(holder.keyword, Keyword.VAR)) {
         _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, holder.keyword);
       }
     }
     if (thisKeyword != null) {
       // TODO(brianwilkerson) If there are type parameters but no parameters,
       // should we create a synthetic empty parameter list here so we can
       // capture the type parameters?
-      return new FieldFormalParameter(
+      return astFactory.fieldFormalParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           holder.keyword,
           holder.type,
           thisKeyword,
           period,
           identifier,
           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));
   }
 
   /**
    * Parse an operator declaration. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
    * The [externalKeyword] is the 'external' token. The [returnType] is the
    * return type that has already been parsed, or `null` if there was no return
    * type. Return the operator declaration that was parsed.
    *
    *     operatorDeclaration ::=
@@ skipping 55 matching lines @@
         type == TokenType.QUESTION_PERIOD ||
         type == TokenType.OPEN_PAREN ||
         type == TokenType.LT ||
         type == TokenType.INDEX) {
       do {
         if (_isLikelyArgumentList()) {
           TypeArgumentList typeArguments = _parseOptionalTypeArguments();
           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 {
           operand = parseAssignableSelector(operand, true);
         }
         type = _currentToken.type;
       } while (type == TokenType.OPEN_SQUARE_BRACKET ||
           type == TokenType.PERIOD ||
           type == TokenType.QUESTION_PERIOD ||
           type == TokenType.OPEN_PAREN ||
           type == TokenType.INDEX);
       return operand;
     }
     if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
     _ensureAssignable(operand);
     Token operator = getAndAdvance();
-    return new PostfixExpression(operand, operator);
+    return astFactory.postfixExpression(operand, operator);
   }
 
   /**
    * Parse a prefixed identifier. Return the prefixed identifier that was
    * parsed.
    *
    *     prefixedIdentifier ::=
    *         identifier ('.' identifier)?
    */
   Identifier parsePrefixedIdentifier() {
@@ skipping 42 matching lines @@
     if (type == TokenType.STRING) {
       return parseStringLiteral();
     } else if (type == TokenType.INT) {
       Token token = getAndAdvance();
       int value = null;
       try {
         value = int.parse(token.lexeme);
       } 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();
       double value = 0.0;
       try {
         value = double.parse(token.lexeme);
       } 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;
       try {
         value = int.parse(token.lexeme.substring(2), radix: 16);
       } 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) {
       if (isFunctionExpression(_currentToken)) {
         return parseFunctionExpression();
       }
       Token leftParenthesis = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression expression = parseExpression2();
         Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
-        return new ParenthesizedExpression(
+        return astFactory.parenthesizedExpression(
             leftParenthesis, expression, rightParenthesis);
       } finally {
         _inInitializer = wasInInitializer;
       }
     } else if (type == TokenType.LT || _injectGenericCommentTypeList()) {
       if (isFunctionExpression(currentToken)) {
         return parseFunctionExpression();
       }
       return parseListOrMapLiteral(null);
     } else if (type == TokenType.OPEN_CURLY_BRACKET) {
@@ skipping 44 matching lines @@
       period = getAndAdvance();
       if (_matchesIdentifier()) {
         constructorName = _parseSimpleIdentifierUnchecked(isDeclaration: false);
       } else {
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
         constructorName = createSyntheticIdentifier(isDeclaration: false);
         _advance();
       }
     }
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new RedirectingConstructorInvocation(
+    return astFactory.redirectingConstructorInvocation(
         keyword, period, constructorName, argumentList);
   }
 
   /**
    * Parse a relational expression. Return the relational expression that was
    * parsed.
    *
    *     relationalExpression ::=
    *         bitwiseOrExpression ('is' '!'? type | 'as' type | relationalOperator bitwiseOrExpression)?
    *       | 'super' relationalOperator bitwiseOrExpression
    */
   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;
   }
 
   /**
    * Parse a rethrow expression. Return the rethrow expression that was parsed.
    *
    * This method assumes that the current token matches `Keyword.RETHROW`.
    *
    *     rethrowExpression ::=
    *         'rethrow'
    */
-  Expression parseRethrowExpression() => new RethrowExpression(getAndAdvance());
+  Expression parseRethrowExpression() =>
+      astFactory.rethrowExpression(getAndAdvance());
 
   /**
    * Parse a return statement. Return the return statement that was parsed.
    *
    * This method assumes that the current token matches `Keyword.RETURN`.
    *
    *     returnStatement ::=
    *         'return' expression? ';'
    */
   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);
   }
 
   /**
    * Parse a return type. Return the return type that was parsed.
    *
    *     returnType ::=
    *         'void'
    *       | type
    */
   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);
     }
   }
 
   /**
    * Parse a setter. The [commentAndMetadata] is the documentation comment and
    * metadata to be associated with the declaration. The [externalKeyword] is
    * the 'external' token. The [staticKeyword] is the static keyword, or `null`
    * if the setter is not static. The [returnType] is the return type that has
@@ skipping 14 matching lines @@
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body = parseFunctionBody(
         externalKeyword != null || staticKeyword == null,
         ParserErrorCode.STATIC_SETTER_WITHOUT_BODY,
         false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         staticKeyword,
         returnType,
         propertyKeyword,
         null,
         name,
         null,
         parameters,
         body);
   }
 
   /**
    * Parse a shift expression. Return the shift expression that was parsed.
    *
    *     shiftExpression ::=
    *         additiveExpression (shiftOperator additiveExpression)*
    *       | 'super' (shiftOperator additiveExpression)+
    */
   Expression parseShiftExpression() {
     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;
   }
 
   /**
    * Parse a simple identifier. Return the simple identifier that was parsed.
    *
    *     identifier ::=
    *         IDENTIFIER
@@ skipping 29 matching lines @@
       if (labels == null) {
         labels = <Label>[label];
       } else {
         labels.add(label);
       }
     }
     Statement statement = parseNonLabeledStatement();
     if (labels == null) {
       return statement;
     }
-    return new LabeledStatement(labels, statement);
+    return astFactory.labeledStatement(labels, statement);
   }
 
   /**
    * Parse a sequence of statements, starting with the given [token]. Return the
    * statements that were parsed, or `null` if the tokens do not represent a
    * recognizable sequence of statements.
    */
   List<Statement> parseStatements(Token token) {
     _currentToken = token;
     return _parseStatementList();
@@ skipping 25 matching lines @@
    */
   SuperConstructorInvocation parseSuperConstructorInvocation() {
     Token keyword = getAndAdvance();
     Token period = null;
     SimpleIdentifier constructorName = null;
     if (_matches(TokenType.PERIOD)) {
       period = getAndAdvance();
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new SuperConstructorInvocation(
+    return astFactory.superConstructorInvocation(
         keyword, period, constructorName, argumentList);
   }
 
   /**
    * Parse a switch statement. Return the switch statement that was parsed.
    *
    *     switchStatement ::=
    *         'switch' '(' expression ')' '{' switchCase* defaultCase? '}'
    *
    *     switchCase ::=
@@ skipping 24 matching lines @@
           String label = identifier.token.lexeme;
           if (definedLabels.contains(label)) {
             _reportErrorForToken(
                 ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT,
                 identifier.token,
                 [label]);
           } else {
             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,
                 caseKeyword);
           }
         } else if (keyword == Keyword.DEFAULT) {
           if (defaultKeyword != null) {
             _reportErrorForToken(
                 ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES, _peek());
           }
           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,
           // but this could be a lot smarter about recovering from the error.
           _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_CASE_OR_DEFAULT);
           bool atEndOrNextMember() {
             TokenType type = _currentToken.type;
             if (type == TokenType.EOF ||
                 type == TokenType.CLOSE_CURLY_BRACKET) {
               return true;
             }
             Keyword keyword = _currentToken.keyword;
             return keyword == Keyword.CASE || keyword == Keyword.DEFAULT;
           }
 
           while (!atEndOrNextMember()) {
             _advance();
           }
         }
         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;
     }
   }
 
   /**
    * Parse a symbol literal. Return the symbol literal that was parsed.
    *
    * This method assumes that the current token matches [TokenType.HASH].
@@ skipping 16 matching lines @@
         }
       }
     } else if (_currentToken.isOperator) {
       components.add(getAndAdvance());
     } else if (_matchesKeyword(Keyword.VOID)) {
       components.add(getAndAdvance());
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       components.add(_createSyntheticToken(TokenType.IDENTIFIER));
     }
-    return new SymbolLiteral(poundSign, components);
+    return astFactory.symbolLiteral(poundSign, components);
   }
 
   /**
    * Parse a throw expression. Return the throw expression that was parsed.
    *
    * This method assumes that the current token matches [Keyword.THROW].
    *
    *     throwExpression ::=
    *         'throw' expression
    */
   Expression parseThrowExpression() {
     Token keyword = getAndAdvance();
     TokenType type = _currentToken.type;
     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);
   }
 
   /**
    * Parse a throw expression. Return the throw expression that was parsed.
    *
    * This method assumes that the current token matches [Keyword.THROW].
    *
    *     throwExpressionWithoutCascade ::=
    *         'throw' expressionWithoutCascade
    */
   Expression parseThrowExpressionWithoutCascade() {
     Token keyword = getAndAdvance();
     TokenType type = _currentToken.type;
     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);
   }
 
   /**
    * Parse a try statement. Return the try statement that was parsed.
    *
    * This method assumes that the current token matches [Keyword.TRY].
    *
    *     tryStatement ::=
    *         'try' block (onPart+ finallyPart? | finallyPart)
    *
@@ skipping 29 matching lines @@
         catchKeyword = getAndAdvance();
         leftParenthesis = _expect(TokenType.OPEN_PAREN);
         exceptionParameter = parseSimpleIdentifier(isDeclaration: true);
         if (_matches(TokenType.COMMA)) {
           comma = getAndAdvance();
           stackTraceParameter = parseSimpleIdentifier(isDeclaration: true);
         }
         rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       }
       Block catchBody = _parseBlockChecked();
-      catchClauses.add(new CatchClause(
+      catchClauses.add(astFactory.catchClause(
           onKeyword,
           exceptionType,
           catchKeyword,
           leftParenthesis,
           exceptionParameter,
           comma,
           stackTraceParameter,
           rightParenthesis,
           catchBody));
     }
     Token finallyKeyword = null;
     if (_matchesKeyword(Keyword.FINALLY)) {
       finallyKeyword = getAndAdvance();
       finallyClause = _parseBlockChecked();
     } else if (catchClauses.isEmpty) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_CATCH_OR_FINALLY);
     }
-    return new TryStatement(
+    return astFactory.tryStatement(
         tryKeyword, body, catchClauses, finallyKeyword, finallyClause);
   }
 
   /**
    * Parse a type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. Return the type alias that was parsed.
    *
    * This method assumes that the current token matches [Keyword.TYPEDEF].
    *
    *     typeAlias ::=
@@ skipping 51 matching lines @@
    *     typeList ::=
    *         type (',' type)*
    */
   TypeArgumentList parseTypeArgumentList() {
     Token leftBracket = getAndAdvance();
     List<TypeName> arguments = <TypeName>[parseTypeName(false)];
     while (_optional(TokenType.COMMA)) {
       arguments.add(parseTypeName(false));
     }
     Token rightBracket = _expectGt();
-    return new TypeArgumentList(leftBracket, arguments, rightBracket);
+    return astFactory.typeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
    * Parse a type name. Return the type name that was parsed.
    *
    *     type ::=
    *         qualified typeArguments?
    */
   TypeName parseTypeName(bool inExpression) {
     TypeName realType = _parseTypeName(inExpression);
@@ skipping 14 matching lines @@
   TypeParameter parseTypeParameter() {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     if (_matches(TokenType.QUESTION)) {
       _reportErrorForCurrentToken(ParserErrorCode.NULLABLE_TYPE_PARAMETER);
       _advance();
     }
     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);
   }
 
   /**
    * Parse a list of type parameters. Return the list of type parameters that
    * were parsed.
    *
    * This method assumes that the current token matches `TokenType.LT`.
    *
    *     typeParameterList ::=
    *         '<' typeParameter (',' typeParameter)* '>'
    */
   TypeParameterList parseTypeParameterList() {
     Token leftBracket = getAndAdvance();
     List<TypeParameter> typeParameters = <TypeParameter>[parseTypeParameter()];
     while (_optional(TokenType.COMMA)) {
       typeParameters.add(parseTypeParameter());
     }
     Token rightBracket = _expectGt();
-    return new TypeParameterList(leftBracket, typeParameters, rightBracket);
+    return astFactory.typeParameterList(
+        leftBracket, typeParameters, rightBracket);
   }
 
   /**
    * Parse a unary expression. Return the unary expression that was parsed.
    *
    *     unaryExpression ::=
    *         prefixOperator unaryExpression
    *       | awaitExpression
    *       | postfixExpression
    *       | unaryOperator 'super'
    *       | '-' 'super'
    *       | incrementOperator assignableExpression
    */
   Expression parseUnaryExpression() {
     TokenType type = _currentToken.type;
     if (type == TokenType.MINUS ||
         type == TokenType.BANG ||
         type == TokenType.TILDE) {
       Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
         TokenType nextType = _peek().type;
         if (nextType == TokenType.OPEN_SQUARE_BRACKET ||
             nextType == TokenType.PERIOD) {
           //     "prefixOperator unaryExpression"
           // --> "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)) {
         TokenType nextType = _peek().type;
         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
         // ('++' or '--') before 'super', we can (and therefore must) interpret
         // "--super" as semantically equivalent to "-(-super)". Unfortunately,
         // we cannot do the same for "++super" because "+super" is also not
         // valid.
         //
         if (type == TokenType.MINUS_MINUS) {
           Token firstOperator = _createToken(operator, TokenType.MINUS);
           Token secondOperator =
               new Token(TokenType.MINUS, operator.offset + 1);
           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);
       return createSyntheticIdentifier();
     } else if (_inAsync && _matchesString(_AWAIT)) {
       return parseAwaitExpression();
     }
     return parsePostfixExpression();
   }
 
@@ skipping 14 matching lines @@
     // of a construct like "class C { int @deprecated foo() {} }" (i.e. the
     // user is in the middle of inserting "int bar;" prior to
     // "@deprecated foo() {}").
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     Token equals = null;
     Expression initializer = null;
     if (_matches(TokenType.EQ)) {
       equals = getAndAdvance();
       initializer = parseExpression2();
     }
-    return new VariableDeclaration(name, equals, initializer);
+    return astFactory.variableDeclaration(name, equals, initializer);
   }
 
   /**
    * Parse a variable declaration list. The [commentAndMetadata] is the metadata
    * to be associated with the variable declaration list. Return the variable
    * declaration list that was parsed.
    *
    *     variableDeclarationList ::=
    *         finalConstVarOrType variableDeclaration (',' variableDeclaration)*
    */
@@ skipping 21 matching lines @@
         keyword != null &&
         _tokenMatchesKeyword(keyword, Keyword.VAR)) {
       _reportErrorForToken(ParserErrorCode.VAR_AND_TYPE, keyword);
     }
     List<VariableDeclaration> variables = <VariableDeclaration>[
       parseVariableDeclaration()
     ];
     while (_optional(TokenType.COMMA)) {
       variables.add(parseVariableDeclaration());
     }
-    return new VariableDeclarationList(commentAndMetadata?.comment,
+    return astFactory.variableDeclarationList(commentAndMetadata?.comment,
         commentAndMetadata?.metadata, keyword, type, variables);
   }
 
   /**
    * Parse a variable declaration statement. The [commentAndMetadata] is the
    * metadata to be associated with the variable declaration statement, or
    * `null` if there is no attempt at parsing the comment and metadata. Return
    * the variable declaration statement that was parsed.
    *
    *     variableDeclarationStatement ::=
    *         variableDeclarationList ';'
    */
   VariableDeclarationStatement parseVariableDeclarationStatementAfterMetadata(
       CommentAndMetadata commentAndMetadata) {
     //    Token startToken = currentToken;
     VariableDeclarationList variableList =
         parseVariableDeclarationListAfterMetadata(commentAndMetadata);
 //        if (!matches(TokenType.SEMICOLON)) {
 //          if (matches(startToken, Keyword.VAR) && isTypedIdentifier(startToken.getNext())) {
 //            // TODO(brianwilkerson) This appears to be of the form "var type variable". We should do
 //            // a better job of recovering in this case.
 //          }
 //        }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new VariableDeclarationStatement(variableList, semicolon);
+    return astFactory.variableDeclarationStatement(variableList, semicolon);
   }
 
   /**
    * Parse a while statement. Return the while statement that was parsed.
    *
    * This method assumes that the current token matches [Keyword.WHILE].
    *
    *     whileStatement ::=
    *         'while' '(' expression ')' statement
    */
   Statement parseWhileStatement() {
     bool wasInLoop = _inLoop;
     _inLoop = true;
     try {
       Token keyword = getAndAdvance();
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       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;
     }
   }
 
   /**
    * Parse a with clause. Return the with clause that was parsed.
    *
    * This method assumes that the current token matches `Keyword.WITH`.
    *
    *     withClause ::=
    *         'with' typeName (',' typeName)*
    */
   WithClause parseWithClause() {
     Token withKeyword = getAndAdvance();
     List<TypeName> types = <TypeName>[];
     do {
       TypeName typeName = parseTypeName(false);
       _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_WITH);
       types.add(typeName);
     } while (_optional(TokenType.COMMA));
-    return new WithClause(withKeyword, types);
+    return astFactory.withClause(withKeyword, types);
   }
 
   /**
    * Parse a yield statement. Return the yield statement that was parsed.
    *
    * This method assumes that the current token matches [Keyword.YIELD].
    *
    *     yieldStatement ::=
    *         'yield' '*'? expression ';'
    */
   YieldStatement parseYieldStatement() {
     Token yieldToken = getAndAdvance();
     Token star = null;
     if (_matches(TokenType.STAR)) {
       star = getAndAdvance();
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new YieldStatement(yieldToken, star, expression, semicolon);
+    return astFactory.yieldStatement(yieldToken, star, expression, semicolon);
   }
 
   /**
    * Parse a prefixed identifier, starting at the [startToken], without actually
    * creating a prefixed identifier or changing the current token. Return the
    * token following the prefixed identifier that was parsed, or `null` if the
    * given token is not the first token in a valid prefixed identifier.
    *
    * This method must be kept in sync with [parsePrefixedIdentifier].
    *
@@ skipping 209 matching lines @@
     current.setNext(tail);
     return head.next;
   }
 
   /**
    * Convert the given [method] declaration into the nearest valid top-level
    * function declaration (that is, the function declaration that most closely
    * 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));
 
   /**
    * Return `true` if the current token could be the start of a compilation unit
    * member. This method is used for recovery purposes to decide when to stop
    * skipping tokens after finding an error while parsing a compilation unit
    * member.
    */
   bool _couldBeStartOfCompilationUnitMember() {
     Keyword keyword = _currentToken.keyword;
@@ skipping 540 matching lines @@
    * when there isn't one. Return the argument list that was parsed.
    */
   ArgumentList _parseArgumentListChecked() {
     if (_matches(TokenType.OPEN_PAREN)) {
       return parseArgumentList();
     }
     _reportErrorForCurrentToken(
         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));
   }
 
   /**
    * Parse an assert within a constructor's initializer list. Return the assert.
    *
    * This method assumes that the current token matches `Keyword.ASSERT`.
    *
    *     assertInitializer ::=
    *         'assert' '(' expression [',' expression] ')'
    */
   AssertInitializer _parseAssertInitializer() {
     Token keyword = getAndAdvance();
     Token leftParen = _expect(TokenType.OPEN_PAREN);
     Expression expression = parseExpression2();
     Token comma;
     Expression message;
     if (_matches(TokenType.COMMA)) {
       comma = getAndAdvance();
       message = parseExpression2();
     }
     Token rightParen = _expect(TokenType.CLOSE_PAREN);
-    return new AssertInitializer(
+    return astFactory.assertInitializer(
         keyword, leftParen, expression, comma, message, rightParen);
   }
 
   /**
    * Parse an assignable expression given that the current token is not 'super'.
    * The [primaryAllowed] is `true` if the expression is allowed to be a primary
    * without any assignable selector. Return the assignable expression that was
    * parsed.
    */
   Expression _parseAssignableExpressionNotStartingWithSuper(
       bool primaryAllowed) {
     //
     // A primary expression can start with an identifier. We resolve the
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
       while (_isLikelyArgumentList()) {
         TypeArgumentList typeArguments = _parseOptionalTypeArguments();
         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) {
           isOptional = false;
         }
       }
       Expression selectorExpression = parseAssignableSelector(
           expression, isOptional || (expression is PrefixedIdentifier));
       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;
       }
       expression = selectorExpression;
       isOptional = true;
     }
   }
 
   /**
    * Parse a block when we need to check for an open curly brace and recover
    * when there isn't one. Return the block that was parsed.
    *
    *     block ::=
    *         '{' statements '}'
    */
   Block _parseBlockChecked() {
     if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
       return parseBlock();
     }
     // TODO(brianwilkerson) Improve the error message.
     _reportErrorForCurrentToken(
         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));
   }
 
   /**
    * Parse a list of class members. The [className] is the name of the class
    * whose members are being parsed. The [closingBracket] is the closing bracket
    * for the class, or `null` if the closing bracket is missing. Return the list
    * of class members that were parsed.
    *
    *     classMembers ::=
    *         (metadata memberDefinition)*
@@ skipping 71 matching lines @@
             ParserErrorCode.EXPECTED_TOKEN, [TokenType.SEMICOLON.lexeme]);
         Token leftBracket = getAndAdvance();
         _parseClassMembers(className.name, _getEndToken(leftBracket));
         _expect(TokenType.CLOSE_CURLY_BRACKET);
       } else {
         _reportErrorForToken(ParserErrorCode.EXPECTED_TOKEN,
             _currentToken.previous, [TokenType.SEMICOLON.lexeme]);
       }
       semicolon = _createSyntheticToken(TokenType.SEMICOLON);
     }
-    return new ClassTypeAlias(
+    return astFactory.classTypeAlias(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         classKeyword,
         className,
         typeParameters,
         equals,
         abstractKeyword,
         superclass,
         withClause,
         implementsClause,
@@ skipping 57 matching lines @@
       if (factoryKeyword != null) {
         _reportErrorForToken(
             ParserErrorCode.FACTORY_WITH_INITIALIZERS, factoryKeyword);
       }
     }
     ConstructorName redirectedConstructor = null;
     FunctionBody body;
     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,
             redirectedConstructor);
       }
     } else {
       body =
           parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
       if (constKeyword != null &&
           factoryKeyword != null &&
@@ skipping 13 matching lines @@
               ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, body);
         } else if (externalKeyword != null) {
           _reportErrorForNode(
               ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_BODY, body);
         } else if (!bodyAllowed) {
           _reportErrorForNode(
               ParserErrorCode.REDIRECTING_CONSTRUCTOR_WITH_BODY, body);
         }
       }
     }
-    return new ConstructorDeclaration(
+    return astFactory.constructorDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         constKeyword,
         factoryKeyword,
         returnType,
         period,
         name,
         parameters,
         separator,
@@ skipping 21 matching lines @@
     SimpleIdentifier name;
     if (_matchesIdentifier()) {
       name = _parseSimpleIdentifierUnchecked(isDeclaration: true);
     } else {
       name = createSyntheticIdentifier();
     }
     if (commentAndMetadata.hasMetadata) {
       _reportErrorForNode(ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT,
           commentAndMetadata.metadata[0]);
     }
-    return new EnumConstantDeclaration(
+    return astFactory.enumConstantDeclaration(
         commentAndMetadata.comment, commentAndMetadata.metadata, name);
   }
 
   /**
    * Parse a list of formal parameters given that the list starts with the given
    * [leftParenthesis]. Return the formal parameters that were parsed.
    */
   FormalParameterList _parseFormalParameterListAfterParen(
       Token leftParenthesis) {
     if (_matches(TokenType.CLOSE_PAREN)) {
-      return new FormalParameterList(
+      return astFactory.formalParameterList(
           leftParenthesis, null, null, null, getAndAdvance());
     }
     //
     // Even though it is invalid to have default parameters outside of brackets,
     // required parameters inside of brackets, or multiple groups of default and
     // named parameters, we allow all of these cases so that we can recover
     // better.
     //
     List<FormalParameter> parameters = <FormalParameter>[];
     Token leftSquareBracket = null;
@@ skipping 129 matching lines @@
     }
     if (leftCurlyBracket != null && rightCurlyBracket == null) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_TERMINATOR_FOR_PARAMETER_GROUP, ["}"]);
     }
     //
     // Build the parameter list.
     //
     leftSquareBracket ??= leftCurlyBracket;
     rightSquareBracket ??= rightCurlyBracket;
-    return new FormalParameterList(leftParenthesis, parameters,
+    return astFactory.formalParameterList(leftParenthesis, parameters,
         leftSquareBracket, rightSquareBracket, rightParenthesis);
   }
 
   /**
    * Parse a list of formal parameters. Return the formal parameters that were
    * parsed.
    *
    * This method assumes that the current token matches `TokenType.OPEN_PAREN`.
    */
   FormalParameterList _parseFormalParameterListUnchecked() {
@@ skipping 16 matching lines @@
     Token propertyKeyword = declaration.propertyKeyword;
     if (propertyKeyword != null) {
       if (propertyKeyword.keyword == Keyword.GET) {
         _reportErrorForToken(
             ParserErrorCode.GETTER_IN_FUNCTION, propertyKeyword);
       } else {
         _reportErrorForToken(
             ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword);
       }
     }
-    return new FunctionDeclarationStatement(declaration);
+    return astFactory.functionDeclarationStatement(declaration);
   }
 
   /**
    * Parse a function type alias. The [commentAndMetadata] is the metadata to be
    * associated with the member. The [keyword] is the token representing the
    * 'typedef' keyword. Return the function type alias that was parsed.
    *
    *     functionTypeAlias ::=
    *         functionPrefix typeParameterList? formalParameterList ';'
    *
    *     functionPrefix ::=
    *         returnType? name
    */
   FunctionTypeAlias _parseFunctionTypeAlias(
       CommentAndMetadata commentAndMetadata, Token keyword) {
     TypeName returnType = null;
     if (hasReturnTypeInTypeAlias) {
       returnType = parseReturnType();
     }
     SimpleIdentifier name = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = null;
     if (_matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     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,
           returnType,
           name,
           typeParameters,
           parameters,
           semicolon);
     } else if (type == TokenType.OPEN_PAREN) {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       _validateFormalParameterList(parameters);
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new FunctionTypeAlias(
+      return astFactory.functionTypeAlias(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           keyword,
           returnType,
           name,
           typeParameters,
           parameters,
           semicolon);
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
       // 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));
     }
   }
 
   /**
    * Parses generic type parameters from a comment.
    *
    * Normally this is handled by [_parseGenericMethodTypeParameters], but if the
    * code already handles the normal generic type parameters, the comment
    * matcher can be called directly. For example, we may have already tried
@@ skipping 35 matching lines @@
     if (_matchesIdentifier()) {
       return parseLibraryIdentifier();
     } else if (_matches(TokenType.STRING)) {
       // Recovery: This should be extended to handle arbitrary tokens until we
       // can find a token that can start a compilation unit member.
       StringLiteral string = parseStringLiteral();
       _reportErrorForNode(ParserErrorCode.NON_IDENTIFIER_LIBRARY_NAME, string);
     } else {
       _reportErrorForToken(missingNameError, missingNameToken);
     }
-    return new LibraryIdentifier(
-        <SimpleIdentifier>[createSyntheticIdentifier()]);
+    return astFactory
+        .libraryIdentifier(<SimpleIdentifier>[createSyntheticIdentifier()]);
   }
 
   /**
    * Parse a method declaration. The [commentAndMetadata] is the documentation
    * comment and metadata to be associated with the declaration. The
    * [externalKeyword] is the 'external' token. The [staticKeyword] is the
    * static keyword, or `null` if the getter is not static. The [returnType] is
    * the return type of the method. The [name] is the name of the method. The
    * [parameters] is the parameters to the method. Return the method declaration
    * that was parsed.
@@ skipping 16 matching lines @@
         false);
     if (externalKeyword != null) {
       if (body is! EmptyFunctionBody) {
         _reportErrorForNode(ParserErrorCode.EXTERNAL_METHOD_WITH_BODY, body);
       }
     } else if (staticKeyword != null) {
       if (body is EmptyFunctionBody && _parseFunctionBodies) {
         _reportErrorForNode(ParserErrorCode.ABSTRACT_STATIC_METHOD, body);
       }
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         staticKeyword,
         returnType,
         null,
         null,
         name,
         typeParameters,
         parameters,
@@ skipping 20 matching lines @@
     SimpleIdentifier methodName = parseSimpleIdentifier(isDeclaration: true);
     TypeParameterList typeParameters = _parseGenericMethodTypeParameters();
     FormalParameterList parameters;
     TokenType type = _currentToken.type;
     // TODO(brianwilkerson) Figure out why we care what the current token is if
     // it isn't a paren.
     if (type != TokenType.OPEN_PAREN &&
         (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,
           null,
           _createSyntheticToken(TokenType.CLOSE_PAREN));
     } else {
       parameters = parseFormalParameterList();
     }
     _validateFormalParameterList(parameters);
     return _parseMethodDeclarationAfterParameters(
@@ skipping 10 matching lines @@
    * Parse a class native clause. Return the native clause that was parsed.
    *
    * This method assumes that the current token matches `_NATIVE`.
    *
    *     classNativeClause ::=
    *         'native' name
    */
   NativeClause _parseNativeClause() {
     Token keyword = getAndAdvance();
     StringLiteral name = parseStringLiteral();
-    return new NativeClause(keyword, name);
+    return astFactory.nativeClause(keyword, name);
   }
 
   /**
    * Parse an operator declaration starting after the 'operator' keyword. The
    * [commentAndMetadata] is the documentation comment and metadata to be
    * associated with the declaration. The [externalKeyword] is the 'external'
    * token. The [returnType] is the return type that has already been parsed, or
    * `null` if there was no return type. The [operatorKeyword] is the 'operator'
    * keyword. Return the operator declaration that was parsed.
    *
    *     operatorDeclaration ::=
    *         operatorSignature (';' | functionBody)
    *
    *     operatorSignature ::=
    *         'external'? returnType? 'operator' operator formalParameterList
    */
   MethodDeclaration _parseOperatorAfterKeyword(
       CommentAndMetadata commentAndMetadata,
       Token externalKeyword,
       TypeName returnType,
       Token operatorKeyword) {
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
           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) ||
               _tokenMatches(previous, TokenType.BANG_EQ)) &&
           _currentToken.offset == previous.offset + 2) {
         _reportErrorForCurrentToken(ParserErrorCode.INVALID_OPERATOR,
             ["${previous.lexeme}${_currentToken.lexeme}"]);
         _advance();
       }
     }
     FormalParameterList parameters = parseFormalParameterList();
     _validateFormalParameterList(parameters);
     FunctionBody body =
         parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         null,
         returnType,
         null,
         operatorKeyword,
         name,
         null,
         parameters,
         body);
   }
 
   /**
    * Parse a return type if one is given, otherwise return `null` without
    * advancing. Return the return type that was parsed.
    */
   TypeName _parseOptionalReturnType() {
     TypeName typeComment = _parseOptionalTypeNameComment();
     if (typeComment != null) {
       return typeComment;
     }
     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 &&
           keyword != Keyword.SET &&
           keyword != Keyword.OPERATOR &&
           (_tokenMatchesIdentifier(next) ||
               _tokenMatches(next, TokenType.LT))) {
         return parseReturnType();
       }
       Token next2 = next.next;
@@ skipping 33 matching lines @@
    *
    * This method assumes that the current token matches `Keyword.PART`.
    *
    *     partDirective ::=
    *         metadata 'part' stringLiteral ';'
    */
   Directive _parsePartDirective(CommentAndMetadata commentAndMetadata) {
     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);
   }
 
   /**
    * Parse a part-of directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the part or part-of directive that
    * was parsed.
    *
    * This method assumes that the current token matches [Keyword.PART] and that
    * the following token matches the identifier 'of'.
    *
    *     partOfDirective ::=
    *         metadata 'part' 'of' identifier ';'
    */
   Directive _parsePartOfDirective(CommentAndMetadata commentAndMetadata) {
     Token partKeyword = getAndAdvance();
     Token ofKeyword = getAndAdvance();
     if (enableUriInPartOf && _matches(TokenType.STRING)) {
       StringLiteral libraryUri = _parseUri();
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new PartOfDirective(
+      return astFactory.partOfDirective(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           partKeyword,
           ofKeyword,
           libraryUri,
           null,
           semicolon);
     }
     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,
         ofKeyword,
         null,
         libraryName,
         semicolon);
   }
 
   /**
    * Parse a prefixed identifier given that the given [qualifier] was already
    * parsed. Return the prefixed identifier that was parsed.
    *
    *     prefixedIdentifier ::=
    *         identifier ('.' identifier)?
    */
   Identifier _parsePrefixedIdentifierAfterIdentifier(
       SimpleIdentifier qualifier) {
     if (!_matches(TokenType.PERIOD) || _injectGenericCommentTypeList()) {
       return qualifier;
     }
     Token period = getAndAdvance();
     SimpleIdentifier qualified = parseSimpleIdentifier();
-    return new PrefixedIdentifier(qualifier, period, qualified);
+    return astFactory.prefixedIdentifier(qualifier, period, qualified);
   }
 
   /**
    * Parse a prefixed identifier. Return the prefixed identifier that was
    * parsed.
    *
    * This method assumes that the current token matches an identifier.
    *
    *     prefixedIdentifier ::=
    *         identifier ('.' identifier)?
@@ skipping 12 matching lines @@
    *         IDENTIFIER
    */
   SimpleIdentifier _parseSimpleIdentifierUnchecked(
       {bool isDeclaration: false}) {
     String lexeme = _currentToken.lexeme;
     if ((_inAsync || _inGenerator) &&
         (lexeme == ASYNC || lexeme == _AWAIT || lexeme == _YIELD)) {
       _reportErrorForCurrentToken(
           ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER);
     }
-    return new SimpleIdentifier(getAndAdvance(), isDeclaration: isDeclaration);
+    return astFactory.simpleIdentifier(getAndAdvance(),
+        isDeclaration: isDeclaration);
   }
 
   /**
    * Parse a list of statements within a switch statement. Return the statements
    * that were parsed.
    *
    *     statements ::=
    *         statement*
    */
   List<Statement> _parseStatementList() {
@@ skipping 18 matching lines @@
   /**
    * Parse a string literal that contains interpolations. Return the string
    * literal that was parsed.
    *
    * This method assumes that the current token matches either
    * [TokenType.STRING_INTERPOLATION_EXPRESSION] or
    * [TokenType.STRING_INTERPOLATION_IDENTIFIER].
    */
   StringInterpolation _parseStringInterpolation(Token string) {
     List<InterpolationElement> elements = <InterpolationElement>[
-      new InterpolationString(
+      astFactory.interpolationString(
           string, computeStringValue(string.lexeme, true, false))
     ];
     bool hasMore = true;
     bool isExpression = _matches(TokenType.STRING_INTERPOLATION_EXPRESSION);
     while (hasMore) {
       if (isExpression) {
         Token openToken = getAndAdvance();
         bool wasInInitializer = _inInitializer;
         _inInitializer = false;
         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;
         }
       } else {
         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);
   }
 
   /**
    * Parse a string literal. Return the string literal that was parsed.
    *
    * This method assumes that the current token matches `TokenType.STRING`.
    *
    *     stringLiteral ::=
    *         MULTI_LINE_STRING+
    *       | SINGLE_LINE_STRING+
    */
   StringLiteral _parseStringLiteralUnchecked() {
     List<StringLiteral> strings = <StringLiteral>[];
     do {
       Token string = getAndAdvance();
       if (_matches(TokenType.STRING_INTERPOLATION_EXPRESSION) ||
           _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) {
     Identifier typeName;
     if (_matchesIdentifier()) {
       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);
     }
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
     Token question = null;
     if (enableNnbd && _matches(TokenType.QUESTION)) {
       if (!inExpression || !_isConditionalOperator()) {
         question = getAndAdvance();
       }
     }
-    return new TypeName(typeName, typeArguments, question: question);
+    return astFactory.typeName(typeName, typeArguments, question: question);
   }
 
   /**
    * Parse a type name. Return the type name that was parsed.
    *
    * This method assumes that the current token is an identifier.
    *
    *     type ::=
    *         qualified typeArguments?
    */
   TypeName _parseTypeNameAfterIdentifier() {
     Identifier typeName = _parsePrefixedIdentifierUnchecked();
     TypeArgumentList typeArguments = _parseOptionalTypeArguments();
     // If this is followed by a generic method type comment, allow the comment
     // type to replace the real type name.
     // 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);
   }
 
   /**
    * Parse a string literal representing a URI. Return the string literal that
    * was parsed.
    */
   StringLiteral _parseUri() {
     // TODO(brianwilkerson) Should this function also return true for valid
     // top-level keywords?
     bool isKeywordAfterUri(Token token) =>
@@ skipping 36 matching lines @@
           }
           buffer.write(token.lexeme);
           endOffset = token.end;
         }
         String value = buffer.toString();
         Token newToken =
             new StringToken(TokenType.STRING, "'$value'", _currentToken.offset);
         _reportErrorForToken(
             ParserErrorCode.NON_STRING_LITERAL_AS_URI, newToken);
         _currentToken = endToken.next;
-        return new SimpleStringLiteral(newToken, value);
+        return astFactory.simpleStringLiteral(newToken, value);
       }
     }
     return parseStringLiteral();
   }
 
   /**
    * Parse a variable declaration statement. The [commentAndMetadata] is the
    * metadata to be associated with the variable declaration statement, or
    * `null` if there is no attempt at parsing the comment and metadata. The
    * [keyword] is the token representing the 'final', 'const' or 'var' keyword,
    * or `null` if there is no keyword. The [type] is the type of the variables
    * in the list. Return the variable declaration statement that was parsed.
    *
    *     variableDeclarationStatement ::=
    *         variableDeclarationList ';'
    */
   VariableDeclarationStatement _parseVariableDeclarationStatementAfterType(
       CommentAndMetadata commentAndMetadata, Token keyword, TypeName type) {
     VariableDeclarationList variableList =
         parseVariableDeclarationListAfterType(
             commentAndMetadata, keyword, type);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new VariableDeclarationStatement(variableList, semicolon);
+    return astFactory.variableDeclarationStatement(variableList, semicolon);
   }
 
   /**
    * Return the token that is immediately after the current token. This is
    * equivalent to [_peekAt](1).
    */
   Token _peek() => _currentToken.next;
 
   /**
    * Return the token that is the given [distance] after the current token,
@@ skipping 929 matching lines @@
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset)
       : super(keyword, offset);
 
   @override
   int get length => 0;
 
   @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 }