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

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

Index: pkg/analyzer/lib/src/generated/parser.dart
diff --git a/pkg/analyzer/lib/src/generated/parser.dart b/pkg/analyzer/lib/src/generated/parser.dart
index 409960d38de0834a2641b739f6d149b0d51f8913..411f6a945aef94b069713388d253027542167140 100644
--- a/pkg/analyzer/lib/src/generated/parser.dart
+++ b/pkg/analyzer/lib/src/generated/parser.dart
@@ -8,6 +8,7 @@ import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
@@ -393,14 +394,15 @@ class Parser {
     } else {
       syntheticToken = _createSyntheticToken(TokenType.IDENTIFIER);
     }
-    return new SimpleIdentifier(syntheticToken, isDeclaration: isDeclaration);
+    return astFactory.simpleIdentifier(syntheticToken,

[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
@@ -599,12 +601,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isAdditiveOperator) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseMultiplicativeExpression();
     }
     while (_currentToken.type.isAdditiveOperator) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseMultiplicativeExpression());
     }
     return expression;
@@ -631,7 +633,8 @@ class Parser {
     if (_matches(TokenType.OPEN_PAREN)) {
       arguments = parseArgumentList();
     }
-    return new Annotation(atSign, name, period, constructorName, arguments);
+    return astFactory.annotation(
+        atSign, name, period, constructorName, arguments);
   }
 
   /**
@@ -653,7 +656,7 @@ class Parser {
     // namedArgument can have an identifier followed by a colon.
     //
     if (_matchesIdentifier() && _tokenMatches(_peek(), TokenType.COLON)) {
-      return new NamedExpression(parseLabel(), parseExpression2());
+      return astFactory.namedExpression(parseLabel(), parseExpression2());
     } else {
       return parseExpression2();
     }
@@ -674,7 +677,7 @@ class Parser {
   ArgumentList parseArgumentList() {
     Token leftParenthesis = getAndAdvance();
     if (_matches(TokenType.CLOSE_PAREN)) {
-      return new ArgumentList(leftParenthesis, null, getAndAdvance());
+      return astFactory.argumentList(leftParenthesis, null, getAndAdvance());
     }
     //
     // Even though unnamed arguments must all appear before any named arguments,
@@ -712,7 +715,8 @@ class Parser {
       // If there is, then we're more likely missing a comma and should go back
       // to parsing arguments.
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
-      return new ArgumentList(leftParenthesis, arguments, rightParenthesis);
+      return astFactory.argumentList(
+          leftParenthesis, arguments, rightParenthesis);
     } finally {
       _inInitializer = wasInInitializer;
     }
@@ -738,7 +742,7 @@ class Parser {
     }
     Token rightParen = _expect(TokenType.CLOSE_PAREN);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new AssertStatement(
+    return astFactory.assertStatement(
         keyword, leftParen, expression, comma, message, rightParen, semicolon);
   }
 
@@ -755,7 +759,7 @@ class Parser {
   Expression parseAssignableExpression(bool primaryAllowed) {
     if (_matchesKeyword(Keyword.SUPER)) {
       return parseAssignableSelector(
-          new SuperExpression(getAndAdvance()), false,
+          astFactory.superExpression(getAndAdvance()), false,
           allowConditional: false);
     }
     return _parseAssignableExpressionNotStartingWithSuper(primaryAllowed);
@@ -786,7 +790,7 @@ class Parser {
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
-        return new IndexExpression.forTarget(
+        return astFactory.indexExpressionForTarget(
             prefix, leftBracket, index, rightBracket);
       } finally {
         _inInitializer = wasInInitializer;
@@ -800,13 +804,14 @@ class Parser {
               [_currentToken.lexeme]);
         }
         Token operator = getAndAdvance();
-        return new PropertyAccess(prefix, operator, parseSimpleIdentifier());
+        return astFactory.propertyAccess(
+            prefix, operator, parseSimpleIdentifier());
       } else if (type == TokenType.INDEX) {
         _splitIndex();
         Token leftBracket = getAndAdvance();
         Expression index = parseSimpleIdentifier();
         Token rightBracket = getAndAdvance();
-        return new IndexExpression.forTarget(
+        return astFactory.indexExpressionForTarget(
             prefix, leftBracket, index, rightBracket);
       } else {
         if (!optional) {
@@ -830,7 +835,7 @@ class Parser {
   AwaitExpression parseAwaitExpression() {
     Token awaitToken = getAndAdvance();
     Expression expression = parseUnaryExpression();
-    return new AwaitExpression(awaitToken, expression);
+    return astFactory.awaitExpression(awaitToken, expression);
   }
 
   /**
@@ -845,12 +850,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type == TokenType.AMPERSAND) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseShiftExpression();
     }
     while (_currentToken.type == TokenType.AMPERSAND) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseShiftExpression());
     }
     return expression;
@@ -868,12 +873,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type == TokenType.BAR) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseBitwiseXorExpression();
     }
     while (_currentToken.type == TokenType.BAR) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseBitwiseXorExpression());
     }
     return expression;
@@ -891,12 +896,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type == TokenType.CARET) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseBitwiseAndExpression();
     }
     while (_currentToken.type == TokenType.CARET) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseBitwiseAndExpression());
     }
     return expression;
@@ -937,7 +942,7 @@ class Parser {
     // there is, then we're more likely missing a semi-colon and should go back
     // to parsing statements.
     Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
-    return new Block(leftBracket, statements, rightBracket);
+    return astFactory.block(leftBracket, statements, rightBracket);
   }
 
   /**
@@ -958,7 +963,7 @@ class Parser {
       _reportErrorForToken(ParserErrorCode.BREAK_OUTSIDE_OF_LOOP, breakKeyword);
     }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new BreakStatement(breakKeyword, label, semicolon);
+    return astFactory.breakStatement(breakKeyword, label, semicolon);
   }
 
   /**
@@ -992,7 +997,7 @@ class Parser {
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
-        expression = new IndexExpression.forCascade(
+        expression = astFactory.indexExpressionForCascade(
             period, leftBracket, index, rightBracket);
         period = null;
       } finally {
@@ -1009,21 +1014,21 @@ class Parser {
       do {
         TypeArgumentList typeArguments = _parseOptionalTypeArguments();
         if (functionName != null) {
-          expression = new MethodInvocation(expression, period, functionName,
-              typeArguments, parseArgumentList());
+          expression = astFactory.methodInvocation(expression, period,
+              functionName, typeArguments, parseArgumentList());
           period = null;
           functionName = null;
         } else if (expression == null) {
           // It should not be possible to get here.
-          expression = new MethodInvocation(expression, period,
+          expression = astFactory.methodInvocation(expression, period,
               createSyntheticIdentifier(), typeArguments, parseArgumentList());
         } else {
-          expression = new FunctionExpressionInvocation(
+          expression = astFactory.functionExpressionInvocation(
               expression, typeArguments, parseArgumentList());
         }
       } while (_isLikelyArgumentList());
     } else if (functionName != null) {
-      expression = new PropertyAccess(expression, period, functionName);
+      expression = astFactory.propertyAccess(expression, period, functionName);
       period = null;
     }
     assert(expression != null);
@@ -1038,14 +1043,14 @@ class Parser {
           TypeArgumentList typeArguments = _parseOptionalTypeArguments();
           Expression currentExpression = expression;
           if (currentExpression is PropertyAccess) {
-            expression = new MethodInvocation(
+            expression = astFactory.methodInvocation(
                 currentExpression.target,
                 currentExpression.operator,
                 currentExpression.propertyName,
                 typeArguments,
                 parseArgumentList());
           } else {
-            expression = new FunctionExpressionInvocation(
+            expression = astFactory.functionExpressionInvocation(
                 expression, typeArguments, parseArgumentList());
           }
         }
@@ -1054,7 +1059,7 @@ class Parser {
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
-      expression = new AssignmentExpression(
+      expression = astFactory.assignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
@@ -1176,7 +1181,7 @@ class Parser {
       rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_CLASS_BODY);
     }
-    ClassDeclaration classDeclaration = new ClassDeclaration(
+    ClassDeclaration classDeclaration = astFactory.classDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         abstractKeyword,
@@ -1207,8 +1212,8 @@ class Parser {
     Modifiers modifiers = parseModifiers();
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.VOID) {
-      TypeName returnType =
-          new TypeName(new SimpleIdentifier(getAndAdvance()), null);
+      TypeName returnType = astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
       keyword = _currentToken.keyword;
       Token next = _peek();
       bool isFollowedByIdentifier = _tokenMatchesIdentifier(next);
@@ -1327,14 +1332,15 @@ class Parser {
         // We appear to have found an incomplete field declaration.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
-        VariableDeclaration variable =
-            new VariableDeclaration(createSyntheticIdentifier(), null, null);
+        VariableDeclaration variable = astFactory.variableDeclaration(
+            createSyntheticIdentifier(), null, null);
         List<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(
@@ -1347,7 +1353,7 @@ class Parser {
         // to loose, so we'll treat it as a method declaration with a missing
         // name, parameters and empty body.
         //
-        return new MethodDeclaration(
+        return astFactory.methodDeclaration(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             null,
@@ -1357,9 +1363,10 @@ class Parser {
             null,
             createSyntheticIdentifier(isDeclaration: true),
             null,
-            new FormalParameterList(
+            astFactory.formalParameterList(
                 null, <FormalParameter>[], null, null, null),
-            new EmptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
+            astFactory
+                .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
     } else if (_tokenMatches(next, TokenType.PERIOD) &&
@@ -1387,7 +1394,7 @@ class Parser {
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            new SimpleIdentifier(methodName.token, isDeclaration: false),
+            astFactory.simpleIdentifier(methodName.token, isDeclaration: false),
             null,
             null,
             parameters);
@@ -1495,7 +1502,7 @@ class Parser {
             modifiers.externalKeyword,
             _validateModifiersForConstructor(modifiers),
             modifiers.factoryKeyword,
-            new SimpleIdentifier(methodName.token, isDeclaration: true),
+            astFactory.simpleIdentifier(methodName.token, isDeclaration: true),
             null,
             null,
             parameters);
@@ -1563,9 +1570,9 @@ class Parser {
    */
   Combinator parseCombinator() {
     if (_matchesString(_SHOW)) {
-      return new ShowCombinator(getAndAdvance(), parseIdentifierList());
+      return astFactory.showCombinator(getAndAdvance(), parseIdentifierList());
     } else if (_matchesString(_HIDE)) {
-      return new HideCombinator(getAndAdvance(), parseIdentifierList());
+      return astFactory.hideCombinator(getAndAdvance(), parseIdentifierList());
     }
     return null;
   }
@@ -1645,7 +1652,8 @@ class Parser {
         Token syntheticToken =
             new SyntheticStringToken(TokenType.IDENTIFIER, "", sourceOffset);
         syntheticToken.setNext(firstToken);
-        return new CommentReference(null, new SimpleIdentifier(syntheticToken));
+        return astFactory.commentReference(
+            null, astFactory.simpleIdentifier(syntheticToken));
       }
       Token newKeyword = null;
       if (_tokenMatchesKeyword(firstToken, Keyword.NEW)) {
@@ -1656,16 +1664,16 @@ class Parser {
         if (firstToken.next.type != TokenType.EOF) {
           return null;
         }
-        Identifier identifier = new SimpleIdentifier(firstToken);
-        return new CommentReference(null, identifier);
+        Identifier identifier = astFactory.simpleIdentifier(firstToken);
+        return astFactory.commentReference(null, identifier);
       } else if (_tokenMatchesKeyword(firstToken, Keyword.OPERATOR)) {
         Token secondToken = firstToken.next;
         if (secondToken.isUserDefinableOperator) {
           if (secondToken.next.type != TokenType.EOF) {
             return null;
           }
-          Identifier identifier = new SimpleIdentifier(secondToken);
-          return new CommentReference(null, identifier);
+          Identifier identifier = astFactory.simpleIdentifier(secondToken);
+          return astFactory.commentReference(null, identifier);
         }
         return null;
       } else if (_tokenMatchesIdentifier(firstToken)) {
@@ -1675,37 +1683,37 @@ class Parser {
         Identifier identifier;
         if (_tokenMatches(secondToken, TokenType.PERIOD)) {
           if (thirdToken.isUserDefinableOperator) {
-            identifier = new PrefixedIdentifier(
-                new SimpleIdentifier(firstToken),
+            identifier = astFactory.prefixedIdentifier(
+                astFactory.simpleIdentifier(firstToken),
                 secondToken,
-                new SimpleIdentifier(thirdToken));
+                astFactory.simpleIdentifier(thirdToken));
             nextToken = thirdToken.next;
           } else if (_tokenMatchesKeyword(thirdToken, Keyword.OPERATOR)) {
             Token fourthToken = thirdToken.next;
             if (fourthToken.isUserDefinableOperator) {
-              identifier = new PrefixedIdentifier(
-                  new SimpleIdentifier(firstToken),
+              identifier = astFactory.prefixedIdentifier(
+                  astFactory.simpleIdentifier(firstToken),
                   secondToken,
-                  new SimpleIdentifier(fourthToken));
+                  astFactory.simpleIdentifier(fourthToken));
               nextToken = fourthToken.next;
             } else {
               return null;
             }
           } else if (_tokenMatchesIdentifier(thirdToken)) {
-            identifier = new PrefixedIdentifier(
-                new SimpleIdentifier(firstToken),
+            identifier = astFactory.prefixedIdentifier(
+                astFactory.simpleIdentifier(firstToken),
                 secondToken,
-                new SimpleIdentifier(thirdToken));
+                astFactory.simpleIdentifier(thirdToken));
             nextToken = thirdToken.next;
           }
         } else {
-          identifier = new SimpleIdentifier(firstToken);
+          identifier = astFactory.simpleIdentifier(firstToken);
           nextToken = firstToken.next;
         }
         if (nextToken.type != TokenType.EOF) {
           return null;
         }
-        return new CommentReference(newKeyword, identifier);
+        return astFactory.commentReference(newKeyword, identifier);
       } else {
         Keyword keyword = firstToken.keyword;
         if (keyword == Keyword.THIS ||
@@ -1795,8 +1803,8 @@ class Parser {
                   TokenType.IDENTIFIER, '', nameOffset);
             }
             nameToken.setNext(new SimpleToken(TokenType.EOF, nameToken.end));
-            references.add(
-                new CommentReference(null, new SimpleIdentifier(nameToken)));
+            references.add(astFactory.commentReference(
+                null, astFactory.simpleIdentifier(nameToken)));
             token.references.add(nameToken);
             // next character
             rightIndex = leftIndex + 1;
@@ -1840,7 +1848,7 @@ class Parser {
     Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (_matches(TokenType.SCRIPT_TAG)) {
-      scriptTag = new ScriptTag(getAndAdvance());
+      scriptTag = astFactory.scriptTag(getAndAdvance());
     }
     //
     // Even though all directives must appear before declarations and must occur
@@ -1971,7 +1979,7 @@ class Parser {
 //        }
       }
     }
-    return new CompilationUnit(
+    return astFactory.compilationUnit(
         firstToken, scriptTag, directives, declarations, _currentToken);
   }
 
@@ -2012,8 +2020,8 @@ class Parser {
       _validateModifiersForEnum(modifiers);
       return parseEnumDeclaration(commentAndMetadata);
     } else if (keyword == Keyword.VOID) {
-      TypeName returnType =
-          new TypeName(new SimpleIdentifier(getAndAdvance()), null);
+      TypeName returnType = astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
       keyword = _currentToken.keyword;
       next = _peek();
       if ((keyword == Keyword.GET || keyword == Keyword.SET) &&
@@ -2052,7 +2060,7 @@ class Parser {
             // We appear to have a variable declaration with a type of "void".
             //
             _reportErrorForNode(ParserErrorCode.VOID_VARIABLE, returnType);
-            return new TopLevelVariableDeclaration(
+            return astFactory.topLevelVariableDeclaration(
                 commentAndMetadata.comment,
                 commentAndMetadata.metadata,
                 parseVariableDeclarationListAfterType(null,
@@ -2089,13 +2097,14 @@ class Parser {
         // We appear to have found an incomplete top-level variable declaration.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
-        VariableDeclaration variable =
-            new VariableDeclaration(createSyntheticIdentifier(), null, null);
+        VariableDeclaration variable = astFactory.variableDeclaration(
+            createSyntheticIdentifier(), null, null);
         List<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);
@@ -2119,7 +2128,7 @@ class Parser {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
-      return new TopLevelVariableDeclaration(
+      return astFactory.topLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           parseVariableDeclarationListAfterType(
@@ -2142,7 +2151,7 @@ class Parser {
           returnType,
           getAndAdvance()));
     } else if (_matches(TokenType.AT)) {
-      return new TopLevelVariableDeclaration(
+      return astFactory.topLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           parseVariableDeclarationListAfterType(null,
@@ -2158,13 +2167,14 @@ class Parser {
       } else {
         semicolon = _createSyntheticToken(TokenType.SEMICOLON);
       }
-      VariableDeclaration variable =
-          new VariableDeclaration(createSyntheticIdentifier(), null, null);
+      VariableDeclaration variable = astFactory.variableDeclaration(
+          createSyntheticIdentifier(), null, null);
       List<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,
@@ -2176,7 +2186,7 @@ class Parser {
       return parseFunctionDeclaration(
           commentAndMetadata, modifiers.externalKeyword, returnType);
     }
-    return new TopLevelVariableDeclaration(
+    return astFactory.topLevelVariableDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         parseVariableDeclarationListAfterType(
@@ -2200,7 +2210,7 @@ class Parser {
     Expression thenExpression = parseExpressionWithoutCascade();
     Token colon = _expect(TokenType.COLON);
     Expression elseExpression = parseExpressionWithoutCascade();
-    return new ConditionalExpression(
+    return astFactory.conditionalExpression(
         condition, question, thenExpression, colon, elseExpression);
   }
 
@@ -2234,8 +2244,8 @@ class Parser {
     }
     Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
     StringLiteral libraryUri = _parseUri();
-    return new Configuration(ifKeyword, leftParenthesis, name, equalToken,
-        value, rightParenthesis, libraryUri);
+    return astFactory.configuration(ifKeyword, leftParenthesis, name,
+        equalToken, value, rightParenthesis, libraryUri);
   }
 
   /**
@@ -2292,8 +2302,12 @@ class Parser {
           type != TokenType.FUNCTION) {
         equals = _createSyntheticToken(TokenType.EQ);
       } else {
-        return new ConstructorFieldInitializer(keywordToken, period, fieldName,
-            _createSyntheticToken(TokenType.EQ), createSyntheticIdentifier());
+        return astFactory.constructorFieldInitializer(
+            keywordToken,
+            period,
+            fieldName,
+            _createSyntheticToken(TokenType.EQ),
+            createSyntheticIdentifier());
       }
     }
     bool wasInInitializer = _inInitializer;
@@ -2308,9 +2322,9 @@ class Parser {
             cascadeSections.add(section);
           }
         } while (_matches(TokenType.PERIOD_PERIOD));
-        expression = new CascadeExpression(expression, cascadeSections);
+        expression = astFactory.cascadeExpression(expression, cascadeSections);
       }
-      return new ConstructorFieldInitializer(
+      return astFactory.constructorFieldInitializer(
           keywordToken, period, fieldName, equals, expression);
     } finally {
       _inInitializer = wasInInitializer;
@@ -2332,7 +2346,7 @@ class Parser {
       period = getAndAdvance();
       name = parseSimpleIdentifier();
     }
-    return new ConstructorName(type, period, name);
+    return astFactory.constructorName(type, period, name);
   }
 
   /**
@@ -2358,7 +2372,7 @@ class Parser {
           ParserErrorCode.CONTINUE_WITHOUT_LABEL_IN_CASE, continueKeyword);
     }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ContinueStatement(continueKeyword, label, semicolon);
+    return astFactory.continueStatement(continueKeyword, label, semicolon);
   }
 
   /**
@@ -2411,7 +2425,7 @@ class Parser {
     Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (_matches(TokenType.SCRIPT_TAG)) {
-      scriptTag = new ScriptTag(getAndAdvance());
+      scriptTag = astFactory.scriptTag(getAndAdvance());
     }
     List<Directive> directives = <Directive>[];
     while (!_matches(TokenType.EOF)) {
@@ -2432,11 +2446,11 @@ class Parser {
         while (!_matches(TokenType.EOF)) {
           _advance();
         }
-        return new CompilationUnit(
+        return astFactory.compilationUnit(
             firstToken, scriptTag, directives, null, _currentToken);
       }
     }
-    return new CompilationUnit(
+    return astFactory.compilationUnit(
         firstToken, scriptTag, directives, null, _currentToken);
   }
 
@@ -2454,7 +2468,7 @@ class Parser {
       return null;
     }
     List<CommentReference> references = parseCommentReferences(tokens);
-    return Comment.createDocumentationCommentWithReferences(tokens, references);
+    return astFactory.documentationComment(tokens, references);
   }
 
   /**
@@ -2505,8 +2519,8 @@ class Parser {
       Expression condition = parseExpression2();
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new DoStatement(doKeyword, body, whileKeyword, leftParenthesis,
-          condition, rightParenthesis, semicolon);
+      return astFactory.doStatement(doKeyword, body, whileKeyword,
+          leftParenthesis, condition, rightParenthesis, semicolon);
     } finally {
       _inLoop = wasInLoop;
     }
@@ -2525,7 +2539,7 @@ class Parser {
     while (_optional(TokenType.PERIOD)) {
       components.add(parseSimpleIdentifier());
     }
-    return new DottedName(components);
+    return astFactory.dottedName(components);
   }
 
   /**
@@ -2536,7 +2550,7 @@ class Parser {
    *     emptyStatement ::=
    *         ';'
    */
-  Statement parseEmptyStatement() => new EmptyStatement(getAndAdvance());
+  Statement parseEmptyStatement() => astFactory.emptyStatement(getAndAdvance());
 
   /**
    * Parse an enum declaration. The [commentAndMetadata] is the metadata to be
@@ -2577,7 +2591,7 @@ class Parser {
       rightBracket = _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET);
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_ENUM_BODY);
     }
-    return new EnumDeclaration(
+    return astFactory.enumDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         keyword,
@@ -2599,7 +2613,7 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isEqualityOperator) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseRelationalExpression();
     }
@@ -2609,7 +2623,7 @@ class Parser {
         _reportErrorForNode(
             ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND, expression);
       }
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseRelationalExpression());
       leftEqualityExpression = true;
     }
@@ -2631,7 +2645,7 @@ class Parser {
     List<Configuration> configurations = _parseConfigurations();
     List<Combinator> combinators = parseCombinators();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ExportDirective(
+    return astFactory.exportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         exportKeyword,
@@ -2684,11 +2698,12 @@ class Parser {
           cascadeSections.add(section);
         }
       } while (_currentToken.type == TokenType.PERIOD_PERIOD);
-      return new CascadeExpression(expression, cascadeSections);
+      return astFactory.cascadeExpression(expression, cascadeSections);
     } else if (type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
-      return new AssignmentExpression(expression, operator, parseExpression2());
+      return astFactory.assignmentExpression(
+          expression, operator, parseExpression2());
     }
     return expression;
   }
@@ -2732,7 +2747,7 @@ class Parser {
     if (_currentToken.type.isAssignmentOperator) {
       Token operator = getAndAdvance();
       _ensureAssignable(expression);
-      expression = new AssignmentExpression(
+      expression = astFactory.assignmentExpression(
           expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
@@ -2751,7 +2766,7 @@ class Parser {
     Token keyword = getAndAdvance();
     TypeName superclass = parseTypeName(false);
     _mustNotBeNullable(superclass, ParserErrorCode.NULLABLE_TYPE_IN_EXTENDS);
-    return new ExtendsClause(keyword, superclass);
+    return astFactory.extendsClause(keyword, superclass);
   }
 
   /**
@@ -2822,7 +2837,7 @@ class Parser {
             ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP, parameter);
         kind = ParameterKind.POSITIONAL;
       }
-      return new DefaultFormalParameter(
+      return astFactory.defaultFormalParameter(
           parameter, kind, separator, defaultValue);
     } else if (type == TokenType.COLON) {
       Token separator = getAndAdvance();
@@ -2836,10 +2851,10 @@ class Parser {
             ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP, parameter);
         kind = ParameterKind.NAMED;
       }
-      return new DefaultFormalParameter(
+      return astFactory.defaultFormalParameter(
           parameter, kind, separator, defaultValue);
     } else if (kind != ParameterKind.REQUIRED) {
-      return new DefaultFormalParameter(parameter, kind, null, null);
+      return astFactory.defaultFormalParameter(parameter, kind, null, null);
     }
     return parameter;
   }
@@ -2912,9 +2927,12 @@ class Parser {
             (_tokenMatchesKeyword(_peek(), Keyword.IN) ||
                 _tokenMatches(_peek(), TokenType.COLON))) {
           SimpleIdentifier variableName = _parseSimpleIdentifierUnchecked();
-          variableList = new VariableDeclarationList(commentAndMetadata.comment,
-              commentAndMetadata.metadata, null, null, <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 =
@@ -2948,12 +2966,12 @@ class Parser {
             Token keyword = variableList.keyword;
             TypeName type = variableList.type;
             if (keyword != null || type != null) {
-              loopVariable = new DeclaredIdentifier(
+              loopVariable = astFactory.declaredIdentifier(
                   commentAndMetadata.comment,
                   commentAndMetadata.metadata,
                   keyword,
                   type,
-                  new SimpleIdentifier(variable.name.token,
+                  astFactory.simpleIdentifier(variable.name.token,
                       isDeclaration: true));
             } else {
               if (commentAndMetadata.hasMetadata) {
@@ -2969,7 +2987,7 @@ class Parser {
           Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
           Statement body = parseStatement2();
           if (loopVariable == null) {
-            return new ForEachStatement.withReference(
+            return astFactory.forEachStatementWithReference(
                 awaitKeyword,
                 forKeyword,
                 leftParenthesis,
@@ -2979,7 +2997,7 @@ class Parser {
                 rightParenthesis,
                 body);
           }
-          return new ForEachStatement.withDeclaration(
+          return astFactory.forEachStatementWithDeclaration(
               awaitKeyword,
               forKeyword,
               leftParenthesis,
@@ -3006,7 +3024,7 @@ class Parser {
       }
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       Statement body = parseStatement2();
-      return new ForStatement(
+      return astFactory.forStatement(
           forKeyword,
           leftParenthesis,
           variableList,
@@ -3053,7 +3071,7 @@ class Parser {
         if (!mayBeEmpty) {
           _reportErrorForCurrentToken(emptyErrorCode);
         }
-        return new EmptyFunctionBody(getAndAdvance());
+        return astFactory.emptyFunctionBody(getAndAdvance());
       }
       Token keyword = null;
       Token star = null;
@@ -3102,10 +3120,10 @@ class Parser {
           semicolon = _expect(TokenType.SEMICOLON);
         }
         if (!_parseFunctionBodies) {
-          return new EmptyFunctionBody(
-              _createSyntheticToken(TokenType.SEMICOLON));
+          return astFactory
+              .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
         }
-        return new ExpressionFunctionBody(
+        return astFactory.expressionFunctionBody(
             keyword, functionDefinition, expression, semicolon);
       } else if (type == TokenType.OPEN_CURLY_BRACKET) {
         if (keyword != null) {
@@ -3116,23 +3134,23 @@ class Parser {
         }
         if (!_parseFunctionBodies) {
           _skipBlock();
-          return new EmptyFunctionBody(
-              _createSyntheticToken(TokenType.SEMICOLON));
+          return astFactory
+              .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
         }
-        return new BlockFunctionBody(keyword, star, parseBlock());
+        return astFactory.blockFunctionBody(keyword, star, parseBlock());
       } else if (_matchesString(_NATIVE)) {
         Token nativeToken = getAndAdvance();
         StringLiteral stringLiteral = null;
         if (_matches(TokenType.STRING)) {
           stringLiteral = _parseStringLiteralUnchecked();
         }
-        return new NativeFunctionBody(
+        return astFactory.nativeFunctionBody(
             nativeToken, stringLiteral, _expect(TokenType.SEMICOLON));
       } else {
         // Invalid function body
         _reportErrorForCurrentToken(emptyErrorCode);
-        return new EmptyFunctionBody(
-            _createSyntheticToken(TokenType.SEMICOLON));
+        return astFactory
+            .emptyFunctionBody(_createSyntheticToken(TokenType.SEMICOLON));
       }
     } finally {
       _inAsync = wasInAsync;
@@ -3170,7 +3188,7 @@ class Parser {
       keywordToken = getAndAdvance();
     }
     if (keywordToken != null && _matches(TokenType.OPEN_PAREN)) {
-      name = new SimpleIdentifier(keywordToken, isDeclaration: true);
+      name = astFactory.simpleIdentifier(keywordToken, isDeclaration: true);
       keywordToken = null;
       isGetter = false;
     } else {
@@ -3185,7 +3203,7 @@ class Parser {
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
-        parameters = new FormalParameterList(
+        parameters = astFactory.formalParameterList(
             _createSyntheticToken(TokenType.OPEN_PAREN),
             null,
             null,
@@ -3201,21 +3219,21 @@ class Parser {
       body = parseFunctionBody(
           false, ParserErrorCode.MISSING_FUNCTION_BODY, false);
     } else {
-      body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON));
+      body = astFactory.emptyFunctionBody(_expect(TokenType.SEMICOLON));
     }
 //        if (!isStatement && matches(TokenType.SEMICOLON)) {
 //          // TODO(brianwilkerson) Improve this error message.
 //          reportError(ParserErrorCode.UNEXPECTED_TOKEN, currentToken.getLexeme());
 //          advance();
 //        }
-    return new FunctionDeclaration(
+    return astFactory.functionDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
         returnType,
         keywordToken,
         name,
-        new FunctionExpression(typeParameters, parameters, body));
+        astFactory.functionExpression(typeParameters, parameters, body));
   }
 
   /**
@@ -3245,7 +3263,7 @@ class Parser {
     _validateFormalParameterList(parameters);
     FunctionBody body =
         parseFunctionBody(false, ParserErrorCode.MISSING_FUNCTION_BODY, true);
-    return new FunctionExpression(typeParameters, parameters, body);
+    return astFactory.functionExpression(typeParameters, parameters, body);
   }
 
   /**
@@ -3281,7 +3299,7 @@ class Parser {
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_GETTER_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
@@ -3321,7 +3339,7 @@ class Parser {
   Expression parseIfNullExpression() {
     Expression expression = parseLogicalOrExpression();
     while (_currentToken.type == TokenType.QUESTION_QUESTION) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseLogicalOrExpression());
     }
     return expression;
@@ -3347,7 +3365,7 @@ class Parser {
       elseKeyword = getAndAdvance();
       elseStatement = parseStatement2();
     }
-    return new IfStatement(ifKeyword, leftParenthesis, condition,
+    return astFactory.ifStatement(ifKeyword, leftParenthesis, condition,
         rightParenthesis, thenStatement, elseKeyword, elseStatement);
   }
 
@@ -3367,7 +3385,7 @@ class Parser {
       _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_IMPLEMENTS);
       interfaces.add(typeName);
     } while (_optional(TokenType.COMMA));
-    return new ImplementsClause(keyword, interfaces);
+    return astFactory.implementsClause(keyword, interfaces);
   }
 
   /**
@@ -3413,7 +3431,7 @@ class Parser {
     }
     List<Combinator> combinators = parseCombinators();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ImportDirective(
+    return astFactory.importDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         importKeyword,
@@ -3452,7 +3470,7 @@ class Parser {
       TypeName type) {
     VariableDeclarationList fieldList =
         parseVariableDeclarationListAfterType(null, keyword, type);
-    return new FieldDeclaration(
+    return astFactory.fieldDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         staticKeyword,
@@ -3471,7 +3489,7 @@ class Parser {
   InstanceCreationExpression parseInstanceCreationExpression(Token keyword) {
     ConstructorName constructorName = parseConstructorName();
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new InstanceCreationExpression(
+    return astFactory.instanceCreationExpression(
         keyword, constructorName, argumentList);
   }
 
@@ -3488,7 +3506,7 @@ class Parser {
     SimpleIdentifier label =
         _parseSimpleIdentifierUnchecked(isDeclaration: isDeclaration);
     Token colon = getAndAdvance();
-    return new Label(label, colon);
+    return astFactory.label(label, colon);
   }
 
   /**
@@ -3507,7 +3525,7 @@ class Parser {
     LibraryIdentifier libraryName = _parseLibraryName(
         ParserErrorCode.MISSING_NAME_IN_LIBRARY_DIRECTIVE, keyword);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new LibraryDirective(commentAndMetadata.comment,
+    return astFactory.libraryDirective(commentAndMetadata.comment,
         commentAndMetadata.metadata, keyword, libraryName, semicolon);
   }
 
@@ -3523,7 +3541,7 @@ class Parser {
     while (_optional(TokenType.PERIOD)) {
       components.add(parseSimpleIdentifier());
     }
-    return new LibraryIdentifier(components);
+    return astFactory.libraryIdentifier(components);
   }
 
   /**
@@ -3541,12 +3559,12 @@ class Parser {
   ListLiteral parseListLiteral(Token modifier, TypeArgumentList typeArguments) {
     if (_matches(TokenType.INDEX)) {
       _splitIndex();
-      return new ListLiteral(
+      return astFactory.listLiteral(
           modifier, typeArguments, getAndAdvance(), null, getAndAdvance());
     }
     Token leftBracket = getAndAdvance();
     if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
-      return new ListLiteral(
+      return astFactory.listLiteral(
           modifier, typeArguments, leftBracket, null, getAndAdvance());
     }
     bool wasInInitializer = _inInitializer;
@@ -3555,13 +3573,13 @@ class Parser {
       List<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;
@@ -3586,7 +3604,7 @@ class Parser {
       return parseListLiteral(modifier, typeArguments);
     }
     _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_LIST_OR_MAP_LITERAL);
-    return new ListLiteral(
+    return astFactory.listLiteral(
         modifier,
         typeArguments,
         _createSyntheticToken(TokenType.OPEN_SQUARE_BRACKET),
@@ -3604,7 +3622,7 @@ class Parser {
   Expression parseLogicalAndExpression() {
     Expression expression = parseEqualityExpression();
     while (_currentToken.type == TokenType.AMPERSAND_AMPERSAND) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseEqualityExpression());
     }
     return expression;
@@ -3620,7 +3638,7 @@ class Parser {
   Expression parseLogicalOrExpression() {
     Expression expression = parseLogicalAndExpression();
     while (_currentToken.type == TokenType.BAR_BAR) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseLogicalAndExpression());
     }
     return expression;
@@ -3641,7 +3659,7 @@ class Parser {
   MapLiteral parseMapLiteral(Token modifier, TypeArgumentList typeArguments) {
     Token leftBracket = getAndAdvance();
     if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
-      return new MapLiteral(
+      return astFactory.mapLiteral(
           modifier, typeArguments, leftBracket, null, getAndAdvance());
     }
     bool wasInInitializer = _inInitializer;
@@ -3650,13 +3668,13 @@ class Parser {
       List<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;
@@ -3673,7 +3691,7 @@ class Parser {
     Expression key = parseExpression2();
     Token separator = _expect(TokenType.COLON);
     Expression value = parseExpression2();
-    return new MapLiteralEntry(key, separator, value);
+    return astFactory.mapLiteralEntry(key, separator, value);
   }
 
   /**
@@ -3773,12 +3791,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isMultiplicativeOperator) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseUnaryExpression();
     }
     while (_currentToken.type.isMultiplicativeOperator) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseUnaryExpression());
     }
     return expression;
@@ -3823,7 +3841,7 @@ class Parser {
       if (_tokenMatches(_peek(), TokenType.STRING)) {
         Token afterString = skipStringLiteral(_currentToken.next);
         if (afterString != null && afterString.type == TokenType.COLON) {
-          return new ExpressionStatement(
+          return astFactory.expressionStatement(
               parseExpression2(), _expect(TokenType.SEMICOLON));
         }
       }
@@ -3846,14 +3864,14 @@ class Parser {
       } else if (keyword == Keyword.IF) {
         return parseIfStatement();
       } else if (keyword == Keyword.RETHROW) {
-        return new ExpressionStatement(
+        return astFactory.expressionStatement(
             parseRethrowExpression(), _expect(TokenType.SEMICOLON));
       } else if (keyword == Keyword.RETURN) {
         return parseReturnStatement();
       } else if (keyword == Keyword.SWITCH) {
         return parseSwitchStatement();
       } else if (keyword == Keyword.THROW) {
-        return new ExpressionStatement(
+        return astFactory.expressionStatement(
             parseThrowExpression(), _expect(TokenType.SEMICOLON));
       } else if (keyword == Keyword.TRY) {
         return parseTryStatement();
@@ -3863,8 +3881,8 @@ class Parser {
         return parseVariableDeclarationStatementAfterMetadata(
             commentAndMetadata);
       } else if (keyword == Keyword.VOID) {
-        TypeName returnType =
-            new TypeName(new SimpleIdentifier(getAndAdvance()), null);
+        TypeName returnType = astFactory.typeName(
+            astFactory.simpleIdentifier(getAndAdvance()), null);
         Token next = _currentToken.next;
         if (_matchesIdentifier() &&
             next.matchesAny(const <TokenType>[
@@ -3902,7 +3920,8 @@ class Parser {
           }
           _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT);
           // TODO(brianwilkerson) Recover from this error.
-          return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
+          return astFactory
+              .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
         }
       } else if (keyword == Keyword.CONST) {
         Token next = _currentToken.next;
@@ -3912,7 +3931,7 @@ class Parser {
           TokenType.OPEN_SQUARE_BRACKET,
           TokenType.INDEX
         ])) {
-          return new ExpressionStatement(
+          return astFactory.expressionStatement(
               parseExpression2(), _expect(TokenType.SEMICOLON));
         } else if (_tokenMatches(next, TokenType.IDENTIFIER)) {
           Token afterType = skipTypeName(next);
@@ -3921,7 +3940,7 @@ class Parser {
                 (_tokenMatches(afterType, TokenType.PERIOD) &&
                     _tokenMatches(afterType.next, TokenType.IDENTIFIER) &&
                     _tokenMatches(afterType.next.next, TokenType.OPEN_PAREN))) {
-              return new ExpressionStatement(
+              return astFactory.expressionStatement(
                   parseExpression2(), _expect(TokenType.SEMICOLON));
             }
           }
@@ -3934,14 +3953,15 @@ class Parser {
           keyword == Keyword.NULL ||
           keyword == Keyword.SUPER ||
           keyword == Keyword.THIS) {
-        return new ExpressionStatement(
+        return astFactory.expressionStatement(
             parseExpression2(), _expect(TokenType.SEMICOLON));
       } else {
         //
         // We have found an error of some kind. Try to recover.
         //
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT);
-        return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
+        return astFactory
+            .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
       }
     } else if (_inGenerator && _matchesString(_YIELD)) {
       return parseYieldStatement();
@@ -3949,7 +3969,7 @@ class Parser {
       if (_tokenMatchesKeyword(_peek(), Keyword.FOR)) {
         return parseForStatement();
       }
-      return new ExpressionStatement(
+      return astFactory.expressionStatement(
           parseExpression2(), _expect(TokenType.SEMICOLON));
     } else if (_matchesString(_AWAIT) &&
         _tokenMatchesKeyword(_peek(), Keyword.FOR)) {
@@ -3968,9 +3988,10 @@ class Parser {
       return parseFunctionDeclarationStatement();
     } else if (type == TokenType.CLOSE_CURLY_BRACKET) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_STATEMENT);
-      return new EmptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
+      return astFactory
+          .emptyStatement(_createSyntheticToken(TokenType.SEMICOLON));
     } else {
-      return new ExpressionStatement(
+      return astFactory.expressionStatement(
           parseExpression2(), _expect(TokenType.SEMICOLON));
     }
   }
@@ -4016,16 +4037,16 @@ class Parser {
         if (enableNnbd && _matches(TokenType.QUESTION)) {
           question = getAndAdvance();
         }
-        return new FunctionTypedFormalParameter(
+        return astFactory.functionTypedFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.type,
-            new SimpleIdentifier(identifier.token, isDeclaration: true),
+            astFactory.simpleIdentifier(identifier.token, isDeclaration: true),
             typeParameters,
             parameters,
             question: question);
       } else {
-        return new FieldFormalParameter(
+        return astFactory.fieldFormalParameter(
             commentAndMetadata.comment,
             commentAndMetadata.metadata,
             holder.keyword,
@@ -4055,7 +4076,7 @@ class Parser {
       // TODO(brianwilkerson) If there are type parameters but no parameters,
       // should we create a synthetic empty parameter list here so we can
       // capture the type parameters?
-      return new FieldFormalParameter(
+      return astFactory.fieldFormalParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           holder.keyword,
@@ -4066,12 +4087,12 @@ class Parser {
           null,
           null);
     }
-    return new SimpleFormalParameter(
+    return astFactory.simpleFormalParameter(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         holder.keyword,
         holder.type,
-        new SimpleIdentifier(identifier.token, isDeclaration: true));
+        astFactory.simpleIdentifier(identifier.token, isDeclaration: true));
   }
 
   /**
@@ -4147,14 +4168,14 @@ class Parser {
           ArgumentList argumentList = parseArgumentList();
           Expression currentOperand = operand;
           if (currentOperand is PropertyAccess) {
-            operand = new MethodInvocation(
+            operand = astFactory.methodInvocation(
                 currentOperand.target,
                 currentOperand.operator,
                 currentOperand.propertyName,
                 typeArguments,
                 argumentList);
           } else {
-            operand = new FunctionExpressionInvocation(
+            operand = astFactory.functionExpressionInvocation(
                 operand, typeArguments, argumentList);
           }
         } else {
@@ -4173,7 +4194,7 @@ class Parser {
     }
     _ensureAssignable(operand);
     Token operator = getAndAdvance();
-    return new PostfixExpression(operand, operator);
+    return astFactory.postfixExpression(operand, operator);
   }
 
   /**
@@ -4236,25 +4257,25 @@ class Parser {
       } on FormatException {
         // The invalid format should have been reported by the scanner.
       }
-      return new IntegerLiteral(token, value);
+      return astFactory.integerLiteral(token, value);
     }
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.NULL) {
-      return new NullLiteral(getAndAdvance());
+      return astFactory.nullLiteral(getAndAdvance());
     } else if (keyword == Keyword.NEW) {
       return parseNewExpression();
     } else if (keyword == Keyword.THIS) {
-      return new ThisExpression(getAndAdvance());
+      return astFactory.thisExpression(getAndAdvance());
     } else if (keyword == Keyword.SUPER) {
       // TODO(paulberry): verify with Gilad that "super" must be followed by
       // unconditionalAssignableSelector in this case.
       return parseAssignableSelector(
-          new SuperExpression(getAndAdvance()), false,
+          astFactory.superExpression(getAndAdvance()), false,
           allowConditional: false);
     } else if (keyword == Keyword.FALSE) {
-      return new BooleanLiteral(getAndAdvance(), false);
+      return astFactory.booleanLiteral(getAndAdvance(), false);
     } else if (keyword == Keyword.TRUE) {
-      return new BooleanLiteral(getAndAdvance(), true);
+      return astFactory.booleanLiteral(getAndAdvance(), true);
     }
     if (type == TokenType.DOUBLE) {
       Token token = getAndAdvance();
@@ -4264,7 +4285,7 @@ class Parser {
       } on FormatException {
         // The invalid format should have been reported by the scanner.
       }
-      return new DoubleLiteral(token, value);
+      return astFactory.doubleLiteral(token, value);
     } else if (type == TokenType.HEXADECIMAL) {
       Token token = getAndAdvance();
       int value = null;
@@ -4273,7 +4294,7 @@ class Parser {
       } on FormatException {
         // The invalid format should have been reported by the scanner.
       }
-      return new IntegerLiteral(token, value);
+      return astFactory.integerLiteral(token, value);
     } else if (keyword == Keyword.CONST) {
       return parseConstExpression();
     } else if (type == TokenType.OPEN_PAREN) {
@@ -4286,7 +4307,7 @@ class Parser {
       try {
         Expression expression = parseExpression2();
         Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
-        return new ParenthesizedExpression(
+        return astFactory.parenthesizedExpression(
             leftParenthesis, expression, rightParenthesis);
       } finally {
         _inInitializer = wasInInitializer;
@@ -4351,7 +4372,7 @@ class Parser {
       }
     }
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new RedirectingConstructorInvocation(
+    return astFactory.redirectingConstructorInvocation(
         keyword, period, constructorName, argumentList);
   }
 
@@ -4366,27 +4387,28 @@ class Parser {
   Expression parseRelationalExpression() {
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isRelationalOperator) {
-      Expression expression = new SuperExpression(getAndAdvance());
+      Expression expression = astFactory.superExpression(getAndAdvance());
       Token operator = getAndAdvance();
-      return new BinaryExpression(
+      return astFactory.binaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     Expression expression = parseBitwiseOrExpression();
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.AS) {
       Token asOperator = getAndAdvance();
-      return new AsExpression(expression, asOperator, parseTypeName(true));
+      return astFactory.asExpression(
+          expression, asOperator, parseTypeName(true));
     } else if (keyword == Keyword.IS) {
       Token isOperator = getAndAdvance();
       Token notOperator = null;
       if (_matches(TokenType.BANG)) {
         notOperator = getAndAdvance();
       }
-      return new IsExpression(
+      return astFactory.isExpression(
           expression, isOperator, notOperator, parseTypeName(true));
     } else if (_currentToken.type.isRelationalOperator) {
       Token operator = getAndAdvance();
-      return new BinaryExpression(
+      return astFactory.binaryExpression(
           expression, operator, parseBitwiseOrExpression());
     }
     return expression;
@@ -4400,7 +4422,8 @@ class Parser {
    *     rethrowExpression ::=
    *         'rethrow'
    */
-  Expression parseRethrowExpression() => new RethrowExpression(getAndAdvance());
+  Expression parseRethrowExpression() =>
+      astFactory.rethrowExpression(getAndAdvance());
 
   /**
    * Parse a return statement. Return the return statement that was parsed.
@@ -4413,11 +4436,11 @@ class Parser {
   Statement parseReturnStatement() {
     Token returnKeyword = getAndAdvance();
     if (_matches(TokenType.SEMICOLON)) {
-      return new ReturnStatement(returnKeyword, null, getAndAdvance());
+      return astFactory.returnStatement(returnKeyword, null, getAndAdvance());
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new ReturnStatement(returnKeyword, expression, semicolon);
+    return astFactory.returnStatement(returnKeyword, expression, semicolon);
   }
 
   /**
@@ -4429,7 +4452,8 @@ class Parser {
    */
   TypeName parseReturnType() {
     if (_currentToken.keyword == Keyword.VOID) {
-      return new TypeName(new SimpleIdentifier(getAndAdvance()), null);
+      return astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
     } else {
       return parseTypeName(false);
     }
@@ -4464,7 +4488,7 @@ class Parser {
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_SETTER_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
@@ -4489,12 +4513,12 @@ class Parser {
     Expression expression;
     if (_currentToken.keyword == Keyword.SUPER &&
         _currentToken.next.type.isShiftOperator) {
-      expression = new SuperExpression(getAndAdvance());
+      expression = astFactory.superExpression(getAndAdvance());
     } else {
       expression = parseAdditiveExpression();
     }
     while (_currentToken.type.isShiftOperator) {
-      expression = new BinaryExpression(
+      expression = astFactory.binaryExpression(
           expression, getAndAdvance(), parseAdditiveExpression());
     }
     return expression;
@@ -4544,7 +4568,7 @@ class Parser {
     if (labels == null) {
       return statement;
     }
-    return new LabeledStatement(labels, statement);
+    return astFactory.labeledStatement(labels, statement);
   }
 
   /**
@@ -4590,7 +4614,7 @@ class Parser {
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList argumentList = _parseArgumentListChecked();
-    return new SuperConstructorInvocation(
+    return astFactory.superConstructorInvocation(
         keyword, period, constructorName, argumentList);
   }
 
@@ -4635,15 +4659,15 @@ class Parser {
             definedLabels.add(label);
           }
           Token colon = getAndAdvance();
-          labels.add(new Label(identifier, colon));
+          labels.add(astFactory.label(identifier, colon));
         }
         Keyword keyword = _currentToken.keyword;
         if (keyword == Keyword.CASE) {
           Token caseKeyword = getAndAdvance();
           Expression caseExpression = parseExpression2();
           Token colon = _expect(TokenType.COLON);
-          members.add(new SwitchCase(labels, caseKeyword, caseExpression, colon,
-              _parseStatementList()));
+          members.add(astFactory.switchCase(labels, caseKeyword, caseExpression,
+              colon, _parseStatementList()));
           if (defaultKeyword != null) {
             _reportErrorForToken(
                 ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE,
@@ -4656,7 +4680,7 @@ class Parser {
           }
           defaultKeyword = getAndAdvance();
           Token colon = _expect(TokenType.COLON);
-          members.add(new SwitchDefault(
+          members.add(astFactory.switchDefault(
               labels, defaultKeyword, colon, _parseStatementList()));
         } else {
           // We need to advance, otherwise we could end up in an infinite loop,
@@ -4679,7 +4703,7 @@ class Parser {
         type = _currentToken.type;
       }
       Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
-      return new SwitchStatement(keyword, leftParenthesis, expression,
+      return astFactory.switchStatement(keyword, leftParenthesis, expression,
           rightParenthesis, leftBracket, members, rightBracket);
     } finally {
       _inSwitch = wasInSwitch;
@@ -4716,7 +4740,7 @@ class Parser {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       components.add(_createSyntheticToken(TokenType.IDENTIFIER));
     }
-    return new SymbolLiteral(poundSign, components);
+    return astFactory.symbolLiteral(poundSign, components);
   }
 
   /**
@@ -4733,10 +4757,10 @@ class Parser {
     if (type == TokenType.SEMICOLON || type == TokenType.CLOSE_PAREN) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_EXPRESSION_IN_THROW, _currentToken);
-      return new ThrowExpression(keyword, createSyntheticIdentifier());
+      return astFactory.throwExpression(keyword, createSyntheticIdentifier());
     }
     Expression expression = parseExpression2();
-    return new ThrowExpression(keyword, expression);
+    return astFactory.throwExpression(keyword, expression);
   }
 
   /**
@@ -4753,10 +4777,10 @@ class Parser {
     if (type == TokenType.SEMICOLON || type == TokenType.CLOSE_PAREN) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_EXPRESSION_IN_THROW, _currentToken);
-      return new ThrowExpression(keyword, createSyntheticIdentifier());
+      return astFactory.throwExpression(keyword, createSyntheticIdentifier());
     }
     Expression expression = parseExpressionWithoutCascade();
-    return new ThrowExpression(keyword, expression);
+    return astFactory.throwExpression(keyword, expression);
   }
 
   /**
@@ -4806,7 +4830,7 @@ class Parser {
         rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       }
       Block catchBody = _parseBlockChecked();
-      catchClauses.add(new CatchClause(
+      catchClauses.add(astFactory.catchClause(
           onKeyword,
           exceptionType,
           catchKeyword,
@@ -4824,7 +4848,7 @@ class Parser {
     } else if (catchClauses.isEmpty) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_CATCH_OR_FINALLY);
     }
-    return new TryStatement(
+    return astFactory.tryStatement(
         tryKeyword, body, catchClauses, finallyKeyword, finallyClause);
   }
 
@@ -4896,7 +4920,7 @@ class Parser {
       arguments.add(parseTypeName(false));
     }
     Token rightBracket = _expectGt();
-    return new TypeArgumentList(leftBracket, arguments, rightBracket);
+    return astFactory.typeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
@@ -4931,10 +4955,10 @@ class Parser {
     if (_matchesKeyword(Keyword.EXTENDS)) {
       Token keyword = getAndAdvance();
       TypeName bound = parseTypeName(false);
-      return new TypeParameter(commentAndMetadata.comment,
+      return astFactory.typeParameter(commentAndMetadata.comment,
           commentAndMetadata.metadata, name, keyword, bound);
     }
-    return new TypeParameter(commentAndMetadata.comment,
+    return astFactory.typeParameter(commentAndMetadata.comment,
         commentAndMetadata.metadata, name, null, null);
   }
 
@@ -4954,7 +4978,8 @@ class Parser {
       typeParameters.add(parseTypeParameter());
     }
     Token rightBracket = _expectGt();
-    return new TypeParameterList(leftBracket, typeParameters, rightBracket);
+    return astFactory.typeParameterList(
+        leftBracket, typeParameters, rightBracket);
   }
 
   /**
@@ -4982,12 +5007,12 @@ class Parser {
           // --> "prefixOperator postfixExpression"
           // --> "prefixOperator primary                    selector*"
           // --> "prefixOperator 'super' assignableSelector selector*"
-          return new PrefixExpression(operator, parseUnaryExpression());
+          return astFactory.prefixExpression(operator, parseUnaryExpression());
         }
-        return new PrefixExpression(
-            operator, new SuperExpression(getAndAdvance()));
+        return astFactory.prefixExpression(
+            operator, astFactory.superExpression(getAndAdvance()));
       }
-      return new PrefixExpression(operator, parseUnaryExpression());
+      return astFactory.prefixExpression(operator, parseUnaryExpression());
     } else if (_currentToken.type.isIncrementOperator) {
       Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
@@ -4995,7 +5020,7 @@ class Parser {
         if (nextType == TokenType.OPEN_SQUARE_BRACKET ||
             nextType == TokenType.PERIOD) {
           // --> "prefixOperator 'super' assignableSelector selector*"
-          return new PrefixExpression(operator, parseUnaryExpression());
+          return astFactory.prefixExpression(operator, parseUnaryExpression());
         }
         //
         // Even though it is not valid to use an incrementing operator
@@ -5011,18 +5036,18 @@ class Parser {
           secondOperator.setNext(_currentToken);
           firstOperator.setNext(secondOperator);
           operator.previous.setNext(firstOperator);
-          return new PrefixExpression(
+          return astFactory.prefixExpression(
               firstOperator,
-              new PrefixExpression(
-                  secondOperator, new SuperExpression(getAndAdvance())));
+              astFactory.prefixExpression(
+                  secondOperator, astFactory.superExpression(getAndAdvance())));
         }
         // Invalid operator before 'super'
         _reportErrorForCurrentToken(
             ParserErrorCode.INVALID_OPERATOR_FOR_SUPER, [operator.lexeme]);
-        return new PrefixExpression(
-            operator, new SuperExpression(getAndAdvance()));
+        return astFactory.prefixExpression(
+            operator, astFactory.superExpression(getAndAdvance()));
       }
-      return new PrefixExpression(
+      return astFactory.prefixExpression(
           operator, _parseAssignableExpressionNotStartingWithSuper(false));
     } else if (type == TokenType.PLUS) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
@@ -5057,7 +5082,7 @@ class Parser {
       equals = getAndAdvance();
       initializer = parseExpression2();
     }
-    return new VariableDeclaration(name, equals, initializer);
+    return astFactory.variableDeclaration(name, equals, initializer);
   }
 
   /**
@@ -5099,7 +5124,7 @@ class Parser {
     while (_optional(TokenType.COMMA)) {
       variables.add(parseVariableDeclaration());
     }
-    return new VariableDeclarationList(commentAndMetadata?.comment,
+    return astFactory.variableDeclarationList(commentAndMetadata?.comment,
         commentAndMetadata?.metadata, keyword, type, variables);
   }
 
@@ -5124,7 +5149,7 @@ class Parser {
 //          }
 //        }
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new VariableDeclarationStatement(variableList, semicolon);
+    return astFactory.variableDeclarationStatement(variableList, semicolon);
   }
 
   /**
@@ -5144,7 +5169,7 @@ class Parser {
       Expression condition = parseExpression2();
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       Statement body = parseStatement2();
-      return new WhileStatement(
+      return astFactory.whileStatement(
           keyword, leftParenthesis, condition, rightParenthesis, body);
     } finally {
       _inLoop = wasInLoop;
@@ -5167,7 +5192,7 @@ class Parser {
       _mustNotBeNullable(typeName, ParserErrorCode.NULLABLE_TYPE_IN_WITH);
       types.add(typeName);
     } while (_optional(TokenType.COMMA));
-    return new WithClause(withKeyword, types);
+    return astFactory.withClause(withKeyword, types);
   }
 
   /**
@@ -5186,7 +5211,7 @@ class Parser {
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new YieldStatement(yieldToken, star, expression, semicolon);
+    return astFactory.yieldStatement(yieldToken, star, expression, semicolon);
   }
 
   /**
@@ -5416,14 +5441,14 @@ class Parser {
    * captures the components of the given method declaration).
    */
   FunctionDeclaration _convertToFunctionDeclaration(MethodDeclaration method) =>
-      new FunctionDeclaration(
+      astFactory.functionDeclaration(
           method.documentationComment,
           method.metadata,
           method.externalKeyword,
           method.returnType,
           method.propertyKeyword,
           method.name,
-          new FunctionExpression(
+          astFactory.functionExpression(
               method.typeParameters, method.parameters, method.body));
 
   /**
@@ -5984,8 +6009,8 @@ class Parser {
         ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_PAREN.lexeme]);
     // Recovery: Look to see whether there is a close paren that isn't matched
     // to an open paren and if so parse the list of arguments as normal.
-    return new ArgumentList(_createSyntheticToken(TokenType.OPEN_PAREN), null,
-        _createSyntheticToken(TokenType.CLOSE_PAREN));
+    return astFactory.argumentList(_createSyntheticToken(TokenType.OPEN_PAREN),
+        null, _createSyntheticToken(TokenType.CLOSE_PAREN));
   }
 
   /**
@@ -6007,7 +6032,7 @@ class Parser {
       message = parseExpression2();
     }
     Token rightParen = _expect(TokenType.CLOSE_PAREN);
-    return new AssertInitializer(
+    return astFactory.assertInitializer(
         keyword, leftParen, expression, comma, message, rightParen);
   }
 
@@ -6032,24 +6057,24 @@ class Parser {
         ArgumentList argumentList = parseArgumentList();
         Expression currentExpression = expression;
         if (currentExpression is SimpleIdentifier) {
-          expression = new MethodInvocation(
+          expression = astFactory.methodInvocation(
               null, null, currentExpression, typeArguments, argumentList);
         } else if (currentExpression is PrefixedIdentifier) {
-          expression = new MethodInvocation(
+          expression = astFactory.methodInvocation(
               currentExpression.prefix,
               currentExpression.period,
               currentExpression.identifier,
               typeArguments,
               argumentList);
         } else if (currentExpression is PropertyAccess) {
-          expression = new MethodInvocation(
+          expression = astFactory.methodInvocation(
               currentExpression.target,
               currentExpression.operator,
               currentExpression.propertyName,
               typeArguments,
               argumentList);
         } else {
-          expression = new FunctionExpressionInvocation(
+          expression = astFactory.functionExpressionInvocation(
               expression, typeArguments, argumentList);
         }
         if (!primaryAllowed) {
@@ -6061,7 +6086,7 @@ class Parser {
       if (identical(selectorExpression, expression)) {
         if (!isOptional && (expression is PrefixedIdentifier)) {
           PrefixedIdentifier identifier = expression as PrefixedIdentifier;
-          expression = new PropertyAccess(
+          expression = astFactory.propertyAccess(
               identifier.prefix, identifier.period, identifier.identifier);
         }
         return expression;
@@ -6087,8 +6112,8 @@ class Parser {
         ParserErrorCode.EXPECTED_TOKEN, [TokenType.OPEN_CURLY_BRACKET.lexeme]);
     // Recovery: Check for an unmatched closing curly bracket and parse
     // statements until it is reached.
-    return new Block(_createSyntheticToken(TokenType.OPEN_CURLY_BRACKET), null,
-        _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET));
+    return astFactory.block(_createSyntheticToken(TokenType.OPEN_CURLY_BRACKET),
+        null, _createSyntheticToken(TokenType.CLOSE_CURLY_BRACKET));
   }
 
   /**
@@ -6180,7 +6205,7 @@ class Parser {
       }
       semicolon = _createSyntheticToken(TokenType.SEMICOLON);
     }
-    return new ClassTypeAlias(
+    return astFactory.classTypeAlias(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         classKeyword,
@@ -6258,7 +6283,7 @@ class Parser {
     if (_matches(TokenType.EQ)) {
       separator = getAndAdvance();
       redirectedConstructor = parseConstructorName();
-      body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON));
+      body = astFactory.emptyFunctionBody(_expect(TokenType.SEMICOLON));
       if (factoryKeyword == null) {
         _reportErrorForNode(
             ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR,
@@ -6292,7 +6317,7 @@ class Parser {
         }
       }
     }
-    return new ConstructorDeclaration(
+    return astFactory.constructorDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
@@ -6334,7 +6359,7 @@ class Parser {
       _reportErrorForNode(ParserErrorCode.ANNOTATION_ON_ENUM_CONSTANT,
           commentAndMetadata.metadata[0]);
     }
-    return new EnumConstantDeclaration(
+    return astFactory.enumConstantDeclaration(
         commentAndMetadata.comment, commentAndMetadata.metadata, name);
   }
 
@@ -6345,7 +6370,7 @@ class Parser {
   FormalParameterList _parseFormalParameterListAfterParen(
       Token leftParenthesis) {
     if (_matches(TokenType.CLOSE_PAREN)) {
-      return new FormalParameterList(
+      return astFactory.formalParameterList(
           leftParenthesis, null, null, null, getAndAdvance());
     }
     //
@@ -6495,7 +6520,7 @@ class Parser {
     //
     leftSquareBracket ??= leftCurlyBracket;
     rightSquareBracket ??= rightCurlyBracket;
-    return new FormalParameterList(leftParenthesis, parameters,
+    return astFactory.formalParameterList(leftParenthesis, parameters,
         leftSquareBracket, rightSquareBracket, rightParenthesis);
   }
 
@@ -6532,7 +6557,7 @@ class Parser {
             ParserErrorCode.SETTER_IN_FUNCTION, propertyKeyword);
       }
     }
-    return new FunctionDeclarationStatement(declaration);
+    return astFactory.functionDeclarationStatement(declaration);
   }
 
   /**
@@ -6560,14 +6585,14 @@ class Parser {
     TokenType type = _currentToken.type;
     if (type == TokenType.SEMICOLON || type == TokenType.EOF) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS);
-      FormalParameterList parameters = new FormalParameterList(
+      FormalParameterList parameters = astFactory.formalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN),
           null,
           null,
           null,
           _createSyntheticToken(TokenType.CLOSE_PAREN));
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new FunctionTypeAlias(
+      return astFactory.functionTypeAlias(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           keyword,
@@ -6580,7 +6605,7 @@ class Parser {
       FormalParameterList parameters = _parseFormalParameterListUnchecked();
       _validateFormalParameterList(parameters);
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new FunctionTypeAlias(
+      return astFactory.functionTypeAlias(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           keyword,
@@ -6594,15 +6619,19 @@ class Parser {
       // Recovery: At the very least we should skip to the start of the next
       // valid compilation unit member, allowing for the possibility of finding
       // the typedef parameters before that point.
-      return new FunctionTypeAlias(
+      return astFactory.functionTypeAlias(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           keyword,
           returnType,
           name,
           typeParameters,
-          new FormalParameterList(_createSyntheticToken(TokenType.OPEN_PAREN),
-              null, null, null, _createSyntheticToken(TokenType.CLOSE_PAREN)),
+          astFactory.formalParameterList(
+              _createSyntheticToken(TokenType.OPEN_PAREN),
+              null,
+              null,
+              null,
+              _createSyntheticToken(TokenType.CLOSE_PAREN)),
           _createSyntheticToken(TokenType.SEMICOLON));
     }
   }
@@ -6658,8 +6687,8 @@ class Parser {
     } else {
       _reportErrorForToken(missingNameError, missingNameToken);
     }
-    return new LibraryIdentifier(
-        <SimpleIdentifier>[createSyntheticIdentifier()]);
+    return astFactory
+        .libraryIdentifier(<SimpleIdentifier>[createSyntheticIdentifier()]);
   }
 
   /**
@@ -6696,7 +6725,7 @@ class Parser {
         _reportErrorForNode(ParserErrorCode.ABSTRACT_STATIC_METHOD, body);
       }
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
@@ -6737,7 +6766,7 @@ class Parser {
         (type == TokenType.OPEN_CURLY_BRACKET || type == TokenType.FUNCTION)) {
       _reportErrorForToken(
           ParserErrorCode.MISSING_METHOD_PARAMETERS, _currentToken.previous);
-      parameters = new FormalParameterList(
+      parameters = astFactory.formalParameterList(
           _createSyntheticToken(TokenType.OPEN_PAREN),
           null,
           null,
@@ -6768,7 +6797,7 @@ class Parser {
   NativeClause _parseNativeClause() {
     Token keyword = getAndAdvance();
     StringLiteral name = parseStringLiteral();
-    return new NativeClause(keyword, name);
+    return astFactory.nativeClause(keyword, name);
   }
 
   /**
@@ -6795,7 +6824,7 @@ class Parser {
           ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
     }
     SimpleIdentifier name =
-        new SimpleIdentifier(getAndAdvance(), isDeclaration: true);
+        astFactory.simpleIdentifier(getAndAdvance(), isDeclaration: true);
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
@@ -6813,7 +6842,7 @@ class Parser {
     if (externalKeyword != null && body is! EmptyFunctionBody) {
       _reportErrorForCurrentToken(ParserErrorCode.EXTERNAL_OPERATOR_WITH_BODY);
     }
-    return new MethodDeclaration(
+    return astFactory.methodDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         externalKeyword,
@@ -6838,7 +6867,8 @@ class Parser {
     }
     Keyword keyword = _currentToken.keyword;
     if (keyword == Keyword.VOID) {
-      return new TypeName(new SimpleIdentifier(getAndAdvance()), null);
+      return astFactory.typeName(
+          astFactory.simpleIdentifier(getAndAdvance()), null);
     } else if (_matchesIdentifier()) {
       Token next = _peek();
       if (keyword != Keyword.GET &&
@@ -6892,7 +6922,7 @@ class Parser {
     Token partKeyword = getAndAdvance();
     StringLiteral partUri = _parseUri();
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new PartDirective(commentAndMetadata.comment,
+    return astFactory.partDirective(commentAndMetadata.comment,
         commentAndMetadata.metadata, partKeyword, partUri, semicolon);
   }
 
@@ -6913,7 +6943,7 @@ class Parser {
     if (enableUriInPartOf && _matches(TokenType.STRING)) {
       StringLiteral libraryUri = _parseUri();
       Token semicolon = _expect(TokenType.SEMICOLON);
-      return new PartOfDirective(
+      return astFactory.partOfDirective(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           partKeyword,
@@ -6925,7 +6955,7 @@ class Parser {
     LibraryIdentifier libraryName = _parseLibraryName(
         ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE, ofKeyword);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new PartOfDirective(
+    return astFactory.partOfDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         partKeyword,
@@ -6949,7 +6979,7 @@ class Parser {
     }
     Token period = getAndAdvance();
     SimpleIdentifier qualified = parseSimpleIdentifier();
-    return new PrefixedIdentifier(qualifier, period, qualified);
+    return astFactory.prefixedIdentifier(qualifier, period, qualified);
   }
 
   /**
@@ -6982,7 +7012,8 @@ class Parser {
       _reportErrorForCurrentToken(
           ParserErrorCode.ASYNC_KEYWORD_USED_AS_IDENTIFIER);
     }
-    return new SimpleIdentifier(getAndAdvance(), isDeclaration: isDeclaration);
+    return astFactory.simpleIdentifier(getAndAdvance(),
+        isDeclaration: isDeclaration);
   }
 
   /**
@@ -7021,7 +7052,7 @@ class Parser {
    */
   StringInterpolation _parseStringInterpolation(Token string) {
     List<InterpolationElement> elements = <InterpolationElement>[
-      new InterpolationString(
+      astFactory.interpolationString(
           string, computeStringValue(string.lexeme, true, false))
     ];
     bool hasMore = true;
@@ -7034,8 +7065,8 @@ class Parser {
         try {
           Expression expression = parseExpression2();
           Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
-          elements.add(
-              new InterpolationExpression(openToken, expression, rightBracket));
+          elements.add(astFactory.interpolationExpression(
+              openToken, expression, rightBracket));
         } finally {
           _inInitializer = wasInInitializer;
         }
@@ -7043,24 +7074,25 @@ class Parser {
         Token openToken = getAndAdvance();
         Expression expression = null;
         if (_matchesKeyword(Keyword.THIS)) {
-          expression = new ThisExpression(getAndAdvance());
+          expression = astFactory.thisExpression(getAndAdvance());
         } else {
           expression = parseSimpleIdentifier();
         }
-        elements.add(new InterpolationExpression(openToken, expression, null));
+        elements.add(
+            astFactory.interpolationExpression(openToken, expression, null));
       }
       if (_matches(TokenType.STRING)) {
         string = getAndAdvance();
         isExpression = _matches(TokenType.STRING_INTERPOLATION_EXPRESSION);
         hasMore =
             isExpression || _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER);
-        elements.add(new InterpolationString(
+        elements.add(astFactory.interpolationString(
             string, computeStringValue(string.lexeme, false, !hasMore)));
       } else {
         hasMore = false;
       }
     }
-    return new StringInterpolation(elements);
+    return astFactory.stringInterpolation(elements);
   }
 
   /**
@@ -7080,11 +7112,13 @@ class Parser {
           _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
         strings.add(_parseStringInterpolation(string));
       } else {
-        strings.add(new SimpleStringLiteral(
+        strings.add(astFactory.simpleStringLiteral(
             string, computeStringValue(string.lexeme, true, true)));
       }
     } while (_matches(TokenType.STRING));
-    return strings.length == 1 ? strings[0] : new AdjacentStrings(strings);
+    return strings.length == 1
+        ? strings[0]
+        : astFactory.adjacentStrings(strings);
   }
 
   TypeName _parseTypeName(bool inExpression) {
@@ -7093,7 +7127,7 @@ class Parser {
       typeName = _parsePrefixedIdentifierUnchecked();
     } else if (_matchesKeyword(Keyword.VAR)) {
       _reportErrorForCurrentToken(ParserErrorCode.VAR_AS_TYPE_NAME);
-      typeName = new SimpleIdentifier(getAndAdvance());
+      typeName = astFactory.simpleIdentifier(getAndAdvance());
     } else {
       typeName = createSyntheticIdentifier();
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TYPE_NAME);
@@ -7105,7 +7139,7 @@ class Parser {
         question = getAndAdvance();
       }
     }
-    return new TypeName(typeName, typeArguments, question: question);
+    return astFactory.typeName(typeName, typeArguments, question: question);
   }
 
   /**
@@ -7124,7 +7158,7 @@ class Parser {
     // TODO(jmesserly): this feels like a big hammer. Can we restrict it to
     // only work inside generic methods?
     TypeName typeFromComment = _parseOptionalTypeNameComment();
-    return typeFromComment ?? new TypeName(typeName, typeArguments);
+    return typeFromComment ?? astFactory.typeName(typeName, typeArguments);
   }
 
   /**
@@ -7181,7 +7215,7 @@ class Parser {
         _reportErrorForToken(
             ParserErrorCode.NON_STRING_LITERAL_AS_URI, newToken);
         _currentToken = endToken.next;
-        return new SimpleStringLiteral(newToken, value);
+        return astFactory.simpleStringLiteral(newToken, value);
       }
     }
     return parseStringLiteral();
@@ -7204,7 +7238,7 @@ class Parser {
         parseVariableDeclarationListAfterType(
             commentAndMetadata, keyword, type);
     Token semicolon = _expect(TokenType.SEMICOLON);
-    return new VariableDeclarationStatement(variableList, semicolon);
+    return astFactory.variableDeclarationStatement(variableList, semicolon);
   }
 
   /**