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

pkg/analyzer/test/dart/ast/ast_test.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.test.dart.ast.ast_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../generated/parser_test.dart' show ParserTestCase;
 import '../../generated/test_support.dart';
 
@@ skipping 340 matching lines @@
         declaration.operatorKeyword);
   }
 }
 
 @reflectiveTest
 class NodeListTest extends EngineTestCase {
   void test_add() {
     AstNode parent = AstTestFactory.argumentList();
     AstNode firstNode = AstTestFactory.booleanLiteral(true);
     AstNode secondNode = AstTestFactory.booleanLiteral(false);
-    NodeList<AstNode> list = new NodeList<AstNode>(parent);
+    NodeList<AstNode> list = astFactory.nodeList/*<AstNode>*/(parent);
     list.insert(0, secondNode);
     list.insert(0, firstNode);
     expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     AstNode thirdNode = AstTestFactory.booleanLiteral(false);
     list.insert(1, thirdNode);
     expect(list, hasLength(3));
     expect(list[0], same(firstNode));
     expect(list[1], same(thirdNode));
     expect(list[2], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     expect(thirdNode.parent, same(parent));
   }
 
   void test_add_negative() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list.insert(-1, AstTestFactory.booleanLiteral(true));
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_add_tooBig() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list.insert(1, AstTestFactory.booleanLiteral(true));
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_addAll() {
     AstNode parent = AstTestFactory.argumentList();
     List<AstNode> firstNodes = new List<AstNode>();
     AstNode firstNode = AstTestFactory.booleanLiteral(true);
     AstNode secondNode = AstTestFactory.booleanLiteral(false);
     firstNodes.add(firstNode);
     firstNodes.add(secondNode);
-    NodeList<AstNode> list = new NodeList<AstNode>(parent);
+    NodeList<AstNode> list = astFactory.nodeList/*<AstNode>*/(parent);
     list.addAll(firstNodes);
     expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     List<AstNode> secondNodes = new List<AstNode>();
     AstNode thirdNode = AstTestFactory.booleanLiteral(true);
     AstNode fourthNode = AstTestFactory.booleanLiteral(false);
     secondNodes.add(thirdNode);
     secondNodes.add(fourthNode);
     list.addAll(secondNodes);
     expect(list, hasLength(4));
     expect(list[0], same(firstNode));
     expect(list[1], same(secondNode));
     expect(list[2], same(thirdNode));
     expect(list[3], same(fourthNode));
     expect(firstNode.parent, same(parent));
     expect(secondNode.parent, same(parent));
     expect(thirdNode.parent, same(parent));
     expect(fourthNode.parent, same(parent));
   }
 
   void test_creation() {
     AstNode owner = AstTestFactory.argumentList();
-    NodeList<AstNode> list = new NodeList<AstNode>(owner);
+    NodeList<AstNode> list = astFactory.nodeList/*<AstNode>*/(owner);
     expect(list, isNotNull);
     expect(list, hasLength(0));
     expect(list.owner, same(owner));
   }
 
   void test_get_negative() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list[-1];
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_get_tooBig() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list[1];
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_getBeginToken_empty() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     expect(list.beginToken, isNull);
   }
 
   void test_getBeginToken_nonEmpty() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     AstNode node = AstTestFactory
         .parenthesizedExpression(AstTestFactory.booleanLiteral(true));
     list.add(node);
     expect(list.beginToken, same(node.beginToken));
   }
 
   void test_getEndToken_empty() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     expect(list.endToken, isNull);
   }
 
   void test_getEndToken_nonEmpty() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     AstNode node = AstTestFactory
         .parenthesizedExpression(AstTestFactory.booleanLiteral(true));
     list.add(node);
     expect(list.endToken, same(node.endToken));
   }
 
   void test_indexOf() {
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstTestFactory.booleanLiteral(true);
     AstNode secondNode = AstTestFactory.booleanLiteral(false);
     AstNode thirdNode = AstTestFactory.booleanLiteral(true);
     AstNode fourthNode = AstTestFactory.booleanLiteral(false);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     list.addAll(nodes);
     expect(list, hasLength(3));
     expect(list.indexOf(firstNode), 0);
     expect(list.indexOf(secondNode), 1);
     expect(list.indexOf(thirdNode), 2);
     expect(list.indexOf(fourthNode), -1);
     expect(list.indexOf(null), -1);
   }
 
   void test_remove() {
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstTestFactory.booleanLiteral(true);
     AstNode secondNode = AstTestFactory.booleanLiteral(false);
     AstNode thirdNode = AstTestFactory.booleanLiteral(true);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     list.addAll(nodes);
     expect(list, hasLength(3));
     expect(list.removeAt(1), same(secondNode));
     expect(list, hasLength(2));
     expect(list[0], same(firstNode));
     expect(list[1], same(thirdNode));
   }
 
   void test_remove_negative() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list.removeAt(-1);
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_remove_tooBig() {
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list.removeAt(1);
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_set() {
     List<AstNode> nodes = new List<AstNode>();
     AstNode firstNode = AstTestFactory.booleanLiteral(true);
     AstNode secondNode = AstTestFactory.booleanLiteral(false);
     AstNode thirdNode = AstTestFactory.booleanLiteral(true);
     nodes.add(firstNode);
     nodes.add(secondNode);
     nodes.add(thirdNode);
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     list.addAll(nodes);
     expect(list, hasLength(3));
     AstNode fourthNode = AstTestFactory.integer(0);
     list[1] = fourthNode;
     expect(list, hasLength(3));
     expect(list[0], same(firstNode));
     expect(list[1], same(fourthNode));
     expect(list[2], same(thirdNode));
   }
 
   void test_set_negative() {
     AstNode node = AstTestFactory.booleanLiteral(true);
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list[-1] = node;
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 
   void test_set_tooBig() {
     AstNode node = AstTestFactory.booleanLiteral(true);
     NodeList<AstNode> list =
-        new NodeList<AstNode>(AstTestFactory.argumentList());
+        astFactory.nodeList/*<AstNode>*/(AstTestFactory.argumentList());
     try {
       list[1] = node;
       fail("Expected IndexOutOfBoundsException");
     } on RangeError {
       // Expected
     }
   }
 }
 
 @reflectiveTest
@@ skipping 182 matching lines @@
       parent = parent.parent;
     }
     return child;
   }
 }
 
 @reflectiveTest
 class SimpleStringLiteralTest extends ParserTestCase {
   void test_contentsEnd() {
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
             .contentsEnd,
         2);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString('"X"'), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString('"X"'), "X")
             .contentsEnd,
         2);
 
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString('"""X"""'), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString('"""X"""'), "X")
             .contentsEnd,
         4);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
             .contentsEnd,
         4);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("'''  \nX'''"), "X")
             .contentsEnd,
         7);
 
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
             .contentsEnd,
         3);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString('r"X"'), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString('r"X"'), "X")
             .contentsEnd,
         3);
 
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString('r"""X"""'), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString('r"""X"""'), "X")
             .contentsEnd,
         5);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
             .contentsEnd,
         5);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("r'''  \nX'''"), "X")
             .contentsEnd,
         8);
   }
 
   void test_contentsOffset() {
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
             .contentsOffset,
         1);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
             .contentsOffset,
         1);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X")
             .contentsOffset,
         3);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
             .contentsOffset,
         3);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
             .contentsOffset,
         2);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
             .contentsOffset,
         2);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X")
             .contentsOffset,
         4);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
             .contentsOffset,
         4);
     // leading whitespace
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("''' \ \nX''"), "X")
             .contentsOffset,
         6);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString('r""" \ \nX"""'), "X")
             .contentsOffset,
         7);
   }
 
   void test_isMultiline() {
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
             .isMultiline,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
             .isMultiline,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
             .isMultiline,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
             .isMultiline,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
             .isMultiline,
         isTrue);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
             .isMultiline,
         isTrue);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X")
             .isMultiline,
         isTrue);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X")
             .isMultiline,
         isTrue);
   }
 
   void test_isRaw() {
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isRaw,
-        isFalse);
-    expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X")
             .isRaw,
         isFalse);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X")
+            .isRaw,
+        isFalse);
+    expect(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X")
             .isRaw,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X")
             .isRaw,
         isFalse);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X")
             .isRaw,
         isTrue);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X")
             .isRaw,
         isTrue);
     expect(
-        new SimpleStringLiteral(
+        astFactory
+            .simpleStringLiteral(
                 TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X")
             .isRaw,
         isTrue);
     expect(
-        new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
+        astFactory
+            .simpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X")
             .isRaw,
         isTrue);
   }
 
   void test_isSingleQuoted() {
     // '
     {
       var token = TokenFactory.tokenFromString("'X'");
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isTrue);
     }
     // '''
     {
       var token = TokenFactory.tokenFromString("'''X'''");
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isTrue);
     }
     // "
     {
       var token = TokenFactory.tokenFromString('"X"');
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isFalse);
     }
     // """
     {
       var token = TokenFactory.tokenFromString('"""X"""');
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isFalse);
     }
   }
 
   void test_isSingleQuoted_raw() {
     // r'
     {
       var token = TokenFactory.tokenFromString("r'X'");
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isTrue);
     }
     // r'''
     {
       var token = TokenFactory.tokenFromString("r'''X'''");
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isTrue);
     }
     // r"
     {
       var token = TokenFactory.tokenFromString('r"X"');
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isFalse);
     }
     // r"""
     {
       var token = TokenFactory.tokenFromString('r"""X"""');
-      var node = new SimpleStringLiteral(token, null);
+      var node = astFactory.simpleStringLiteral(token, null);
       expect(node.isSingleQuoted, isFalse);
     }
   }
 
   void test_simple() {
     Token token = TokenFactory.tokenFromString("'value'");
-    SimpleStringLiteral stringLiteral = new SimpleStringLiteral(token, "value");
+    SimpleStringLiteral stringLiteral =
+        astFactory.simpleStringLiteral(token, "value");
     expect(stringLiteral.literal, same(token));
     expect(stringLiteral.beginToken, same(token));
     expect(stringLiteral.endToken, same(token));
     expect(stringLiteral.value, "value");
   }
 }
 
 @reflectiveTest
 class StringInterpolationTest extends ParserTestCase {
   void test_contentsOffsetEnd() {
     AstTestFactory.interpolationExpression(AstTestFactory.identifier3('bb'));
     // 'a${bb}ccc'
     {
       var ae = AstTestFactory.interpolationString("'a", "a");
       var cToken = new StringToken(TokenType.STRING, "ccc'", 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 1);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
     // '''a${bb}ccc'''
     {
       var ae = AstTestFactory.interpolationString("'''a", "a");
       var cToken = new StringToken(TokenType.STRING, "ccc'''", 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 3);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
     // """a${bb}ccc"""
     {
       var ae = AstTestFactory.interpolationString('"""a', "a");
       var cToken = new StringToken(TokenType.STRING, 'ccc"""', 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 3);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
     // r'a${bb}ccc'
     {
       var ae = AstTestFactory.interpolationString("r'a", "a");
       var cToken = new StringToken(TokenType.STRING, "ccc'", 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 2);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
     // r'''a${bb}ccc'''
     {
       var ae = AstTestFactory.interpolationString("r'''a", "a");
       var cToken = new StringToken(TokenType.STRING, "ccc'''", 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 4);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
     // r"""a${bb}ccc"""
     {
       var ae = AstTestFactory.interpolationString('r"""a', "a");
       var cToken = new StringToken(TokenType.STRING, 'ccc"""', 10);
-      var cElement = new InterpolationString(cToken, 'ccc');
+      var cElement = astFactory.interpolationString(cToken, 'ccc');
       StringInterpolation node = AstTestFactory.string([ae, ae, cElement]);
       expect(node.contentsOffset, 4);
       expect(node.contentsEnd, 10 + 4 - 1);
     }
   }
 
   void test_isMultiline() {
     var b = AstTestFactory
         .interpolationExpression(AstTestFactory.identifier3('bb'));
     // '
@@ skipping 64 matching lines @@
     }
   }
 }
 
 @reflectiveTest
 class VariableDeclarationTest extends ParserTestCase {
   void test_getDocumentationComment_onGrandParent() {
     VariableDeclaration varDecl = AstTestFactory.variableDeclaration("a");
     TopLevelVariableDeclaration decl =
         AstTestFactory.topLevelVariableDeclaration2(Keyword.VAR, [varDecl]);
-    Comment comment = Comment.createDocumentationComment(new List<Token>(0));
+    Comment comment = astFactory.documentationComment(new List<Token>(0));
     expect(varDecl.documentationComment, isNull);
     decl.documentationComment = comment;
     expect(varDecl.documentationComment, isNotNull);
     expect(decl.documentationComment, isNotNull);
   }
 
   void test_getDocumentationComment_onNode() {
     VariableDeclaration decl = AstTestFactory.variableDeclaration("a");
-    Comment comment = Comment.createDocumentationComment(new List<Token>(0));
+    Comment comment = astFactory.documentationComment(new List<Token>(0));
     decl.documentationComment = comment;
     expect(decl.documentationComment, isNotNull);
   }
 }
 
 class _AssignmentKind {
   static const _AssignmentKind BINARY = const _AssignmentKind('BINARY', 0);
 
   static const _AssignmentKind COMPOUND_LEFT =
       const _AssignmentKind('COMPOUND_LEFT', 1);
@@ skipping 75 matching lines @@
   final int ordinal;
 
   const _WrapperKind(this.name, this.ordinal);
 
   int get hashCode => ordinal;
 
   int compareTo(_WrapperKind other) => ordinal - other.ordinal;
 
   String toString() => name;
 }