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

pkg/analyzer/test/generated/utilities_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.generated.utilities_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
@@ skipping 1579 matching lines @@
 @reflectiveTest
 class ExceptionHandlingDelegatingAstVisitorTest extends EngineTestCase {
   void test_handlerIsCalled() {
     AstVisitor exceptionThrowingVisitor = new _ExceptionThrowingVisitor();
     bool handlerInvoked = false;
     AstVisitor visitor = new ExceptionHandlingDelegatingAstVisitor(
         [exceptionThrowingVisitor], (AstNode node, AstVisitor visitor,
             dynamic exception, StackTrace stackTrace) {
       handlerInvoked = true;
     });
-    new NullLiteral(null).accept(visitor);
+    astFactory.nullLiteral(null).accept(visitor);
     expect(handlerInvoked, isTrue);
   }
 }
 
 class Getter_NodeReplacerTest_test_annotation
     implements NodeReplacerTest_Getter<Annotation, ArgumentList> {
   @override
   ArgumentList get(Annotation node) => node.arguments;
 }
 
@@ skipping 1436 matching lines @@
     ClassDeclaration node = AstTestFactory.classDeclaration(
         null,
         "A",
         AstTestFactory.typeParameterList(["E"]),
         AstTestFactory.extendsClause(AstTestFactory.typeName4("B")),
         AstTestFactory.withClause([AstTestFactory.typeName4("C")]),
         AstTestFactory.implementsClause([AstTestFactory.typeName4("D")]), [
       AstTestFactory.fieldDeclaration2(
           false, null, [AstTestFactory.variableDeclaration("f")])
     ]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     node.nativeClause = AstTestFactory.nativeClause("");
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_6());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_3());
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_classDeclaration(0));
     _testAnnotatedNode(node);
   }
 
   void test_classTypeAlias() {
     ClassTypeAlias node = AstTestFactory.classTypeAlias(
         "A",
         AstTestFactory.typeParameterList(["E"]),
         null,
         AstTestFactory.typeName4("B"),
         AstTestFactory.withClause([AstTestFactory.typeName4("C")]),
         AstTestFactory.implementsClause([AstTestFactory.typeName4("D")]));
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_3());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_2());
     _testAnnotatedNode(node);
   }
 
   void test_comment() {
-    Comment node = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.references
-        .add(new CommentReference(null, AstTestFactory.identifier3("x")));
+    Comment node = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
+    node.references.add(
+        astFactory.commentReference(null, AstTestFactory.identifier3("x")));
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_comment(0));
   }
 
   void test_commentReference() {
     CommentReference node =
-        new CommentReference(null, AstTestFactory.identifier3("x"));
+        astFactory.commentReference(null, AstTestFactory.identifier3("x"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_commentReference());
   }
 
   void test_compilationUnit() {
     CompilationUnit node = AstTestFactory.compilationUnit8("", [
       AstTestFactory.libraryDirective2("lib")
     ], [
       AstTestFactory.topLevelVariableDeclaration2(
           null, [AstTestFactory.variableDeclaration("X")])
     ]);
@@ skipping 22 matching lines @@
         null,
         null,
         AstTestFactory.identifier3("C"),
         "d",
         AstTestFactory.formalParameterList(),
         [
           AstTestFactory.constructorFieldInitializer(
               false, "x", AstTestFactory.integer(0))
         ],
         AstTestFactory.emptyFunctionBody());
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     node.redirectedConstructor =
         AstTestFactory.constructorName(AstTestFactory.typeName4("B"), "a");
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_constructorDeclaration_3());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_constructorDeclaration_2());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_constructorDeclaration_4());
@@ skipping 23 matching lines @@
   }
 
   void test_continueStatement() {
     ContinueStatement node = AstTestFactory.continueStatement("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_continueStatement());
   }
 
   void test_declaredIdentifier() {
     DeclaredIdentifier node =
         AstTestFactory.declaredIdentifier4(AstTestFactory.typeName4("C"), "i");
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_declaredIdentifier_2());
     _testAnnotatedNode(node);
   }
 
   void test_defaultFormalParameter() {
     DefaultFormalParameter node = AstTestFactory.positionalFormalParameter(
         AstTestFactory.simpleFormalParameter3("p"), AstTestFactory.integer(0));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_defaultFormalParameter());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_defaultFormalParameter_2());
   }
 
   void test_doStatement() {
     DoStatement node = AstTestFactory.doStatement(
         AstTestFactory.block(), AstTestFactory.booleanLiteral(true));
     _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement());
   }
 
   void test_enumConstantDeclaration() {
-    EnumConstantDeclaration node = new EnumConstantDeclaration(
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST),
+    EnumConstantDeclaration node = astFactory.enumConstantDeclaration(
+        astFactory.endOfLineComment(EMPTY_TOKEN_LIST),
         [AstTestFactory.annotation(AstTestFactory.identifier3("a"))],
         AstTestFactory.identifier3("C"));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_enumConstantDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_enumDeclaration() {
     EnumDeclaration node = AstTestFactory.enumDeclaration2("E", ["ONE", "TWO"]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_enumDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_exportDirective() {
     ExportDirective node = AstTestFactory.exportDirective2("", [
       AstTestFactory.hideCombinator2(["C"])
     ]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _testNamespaceDirective(node);
   }
 
   void test_expressionFunctionBody() {
     ExpressionFunctionBody node =
         AstTestFactory.expressionFunctionBody(AstTestFactory.integer(0));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_expressionFunctionBody());
@@ skipping 11 matching lines @@
         AstTestFactory.extendsClause(AstTestFactory.typeName4("S"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_extendsClause());
   }
 
   void test_fieldDeclaration() {
     FieldDeclaration node = AstTestFactory.fieldDeclaration(
         false,
         null,
         AstTestFactory.typeName4("C"),
         [AstTestFactory.variableDeclaration("c")]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_fieldDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_fieldFormalParameter() {
     FieldFormalParameter node = AstTestFactory.fieldFormalParameter(
         null,
         AstTestFactory.typeName4("C"),
         "f",
         AstTestFactory.formalParameterList());
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata = [
       AstTestFactory.annotation(AstTestFactory.identifier3("a"))
     ];
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_fieldFormalParameter_2());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_fieldFormalParameter());
     _testNormalFormalParameter(node);
   }
 
@@ skipping 65 matching lines @@
         new ListGetter_NodeReplacerTest_test_forStatement_withVariables(0));
   }
 
   void test_functionDeclaration() {
     FunctionDeclaration node = AstTestFactory.functionDeclaration(
         AstTestFactory.typeName4("R"),
         null,
         "f",
         AstTestFactory.functionExpression2(AstTestFactory.formalParameterList(),
             AstTestFactory.blockFunctionBody(AstTestFactory.block())));
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionDeclaration());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionDeclaration_3());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionDeclaration_2());
     _testAnnotatedNode(node);
   }
@@ skipping 29 matching lines @@
     _assertReplace(node,
         new Getter_NodeReplacerTest_test_functionExpressionInvocation_2());
   }
 
   void test_functionTypeAlias() {
     FunctionTypeAlias node = AstTestFactory.typeAlias(
         AstTestFactory.typeName4("R"),
         "F",
         AstTestFactory.typeParameterList(["E"]),
         AstTestFactory.formalParameterList());
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionTypeAlias_3());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_functionTypeAlias());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionTypeAlias_2());
     _testAnnotatedNode(node);
   }
 
   void test_functionTypedFormalParameter() {
     FunctionTypedFormalParameter node = AstTestFactory
         .functionTypedFormalParameter(AstTestFactory.typeName4("R"), "f",
             [AstTestFactory.simpleFormalParameter3("p")]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata = [
       AstTestFactory.annotation(AstTestFactory.identifier3("a"))
     ];
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_functionTypedFormalParameter());
     _assertReplace(node,
         new Getter_NodeReplacerTest_test_functionTypedFormalParameter_2());
     _testNormalFormalParameter(node);
   }
 
@@ skipping 18 matching lines @@
         [AstTestFactory.typeName4("I"), AstTestFactory.typeName4("J")]);
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_implementsClause(0));
   }
 
   void test_importDirective() {
     ImportDirective node = AstTestFactory.importDirective3("", "p", [
       AstTestFactory.showCombinator2(["A"]),
       AstTestFactory.hideCombinator2(["B"])
     ]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_importDirective());
     _testNamespaceDirective(node);
   }
 
   void test_indexExpression() {
     IndexExpression node = AstTestFactory.indexExpression(
         AstTestFactory.identifier3("a"), AstTestFactory.identifier3("i"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression());
@@ skipping 31 matching lines @@
   void test_labeledStatement() {
     LabeledStatement node = AstTestFactory
         .labeledStatement([AstTestFactory.label2("l")], AstTestFactory.block());
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_labeledStatement(0));
     _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
   }
 
   void test_libraryDirective() {
     LibraryDirective node = AstTestFactory.libraryDirective2("lib");
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_libraryDirective());
     _testAnnotatedNode(node);
   }
 
   void test_libraryIdentifier() {
     LibraryIdentifier node = AstTestFactory.libraryIdentifier2(["lib"]);
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
@@ skipping 26 matching lines @@
 
   void test_methodDeclaration() {
     MethodDeclaration node = AstTestFactory.methodDeclaration2(
         null,
         AstTestFactory.typeName4("A"),
         null,
         null,
         AstTestFactory.identifier3("m"),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody(AstTestFactory.block()));
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_methodDeclaration());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_methodDeclaration_3());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_methodDeclaration_4());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_methodDeclaration_2());
     _testAnnotatedNode(node);
@@ skipping 26 matching lines @@
 
   void test_parenthesizedExpression() {
     ParenthesizedExpression node =
         AstTestFactory.parenthesizedExpression(AstTestFactory.integer(0));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_parenthesizedExpression());
   }
 
   void test_partDirective() {
     PartDirective node = AstTestFactory.partDirective2("");
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _testUriBasedDirective(node);
   }
 
   void test_partOfDirective() {
     PartOfDirective node = AstTestFactory
         .partOfDirective(AstTestFactory.libraryIdentifier2(["lib"]));
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(node, new Getter_NodeReplacerTest_test_partOfDirective());
     _testAnnotatedNode(node);
   }
 
   void test_postfixExpression() {
     PostfixExpression node = AstTestFactory.postfixExpression(
         AstTestFactory.identifier3("x"), TokenType.MINUS_MINUS);
     _assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression());
@@ skipping 36 matching lines @@
 
   void test_showCombinator() {
     ShowCombinator node = AstTestFactory.showCombinator2(["X", "Y"]);
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_showCombinator(0));
   }
 
   void test_simpleFormalParameter() {
     SimpleFormalParameter node = AstTestFactory.simpleFormalParameter4(
         AstTestFactory.typeName4("T"), "p");
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata = [
       AstTestFactory.annotation(AstTestFactory.identifier3("a"))
     ];
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_simpleFormalParameter());
     _testNormalFormalParameter(node);
   }
 
   void test_stringInterpolation() {
     StringInterpolation node =
@@ skipping 40 matching lines @@
   void test_throwExpression() {
     ThrowExpression node =
         AstTestFactory.throwExpression2(AstTestFactory.identifier3("e"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_throwExpression());
   }
 
   void test_topLevelVariableDeclaration() {
     TopLevelVariableDeclaration node = AstTestFactory
         .topLevelVariableDeclaration(null, AstTestFactory.typeName4("T"),
             [AstTestFactory.variableDeclaration("t")]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_tryStatement() {
     TryStatement node = AstTestFactory.tryStatement3(
         AstTestFactory.block(),
@@ skipping 29 matching lines @@
 
   void test_typeParameterList() {
     TypeParameterList node = AstTestFactory.typeParameterList(["A", "B"]);
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_typeParameterList(0));
   }
 
   void test_variableDeclaration() {
     VariableDeclaration node =
         AstTestFactory.variableDeclaration2("a", AstTestFactory.nullLiteral());
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_variableDeclaration());
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_variableDeclaration_2());
     _testAnnotatedNode(node);
   }
 
   void test_variableDeclarationList() {
     VariableDeclarationList node = AstTestFactory.variableDeclarationList(
         null,
         AstTestFactory.typeName4("T"),
         [AstTestFactory.variableDeclaration("a")]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata
         .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
     _assertReplace(
         node, new Getter_NodeReplacerTest_test_variableDeclarationList());
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_variableDeclarationList(0));
     _testAnnotatedNode(node);
   }
 
   void test_variableDeclarationStatement() {
@@ skipping 556 matching lines @@
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }
 
 class _ExceptionThrowingVisitor extends SimpleAstVisitor {
   visitNullLiteral(NullLiteral node) {
     throw new ArgumentError('');
   }
 }