Rename AstFactory -> AstTestFactory.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-library analyzer.src.generated.testing.ast_factory;
+library analyzer.src.generated.testing.ast_test_factory;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
- * The class `AstFactory` defines utility methods that can be used to create AST nodes. The
+ * The class `AstTestFactory` defines utility methods that can be used to create AST nodes. The
  * nodes that are created are complete in the sense that all of the tokens that would have been
  * associated with the nodes by a parser are also created, but the token stream is not constructed.
  * None of the nodes are resolved.
  *
  * The general pattern is for the name of the factory method to be the same as the name of the class
  * of AST node being created. There are two notable exceptions. The first is for methods creating
  * nodes that are part of a cascade expression. These methods are all prefixed with 'cascaded'. The
  * second is places where a shorter name seemed unambiguous and easier to read, such as using
  * 'identifier' rather than 'prefixedIdentifier', or 'integer' rather than 'integerLiteral'.
  */
-class AstFactory {
+class AstTestFactory {
   static AdjacentStrings adjacentStrings(List<StringLiteral> strings) =>
       new AdjacentStrings(strings);
 
   static Annotation annotation(Identifier name) => new Annotation(
       TokenFactory.tokenFromType(TokenType.AT), name, null, null, null);
 
   static Annotation annotation2(Identifier name,
           SimpleIdentifier constructorName, ArgumentList arguments) =>
       new Annotation(
           TokenFactory.tokenFromType(TokenType.AT),
@@ skipping 225 matching lines @@
   static CompilationUnit compilationUnit7(
           String scriptTag, List<Directive> directives) =>
       compilationUnit8(scriptTag, directives, null);
 
   static CompilationUnit compilationUnit8(
           String scriptTag,
           List<Directive> directives,
           List<CompilationUnitMember> declarations) =>
       new CompilationUnit(
           TokenFactory.tokenFromType(TokenType.EOF),
-          scriptTag == null ? null : AstFactory.scriptTag(scriptTag),
+          scriptTag == null ? null : AstTestFactory.scriptTag(scriptTag),
           directives == null ? new List<Directive>() : directives,
           declarations == null
               ? new List<CompilationUnitMember>()
               : declarations,
           TokenFactory.tokenFromType(TokenType.EOF));
 
   static ConditionalExpression conditionalExpression(Expression condition,
           Expression thenExpression, Expression elseExpression) =>
       new ConditionalExpression(
           condition,
@@ skipping 452 matching lines @@
       new InterpolationString(TokenFactory.tokenFromString(contents), value);
 
   static IsExpression isExpression(
           Expression expression, bool negated, TypeName type) =>
       new IsExpression(expression, TokenFactory.tokenFromKeyword(Keyword.IS),
           negated ? TokenFactory.tokenFromType(TokenType.BANG) : null, type);
 
   static Label label(SimpleIdentifier label) =>
       new Label(label, TokenFactory.tokenFromType(TokenType.COLON));
 
-  static Label label2(String label) => AstFactory.label(identifier3(label));
+  static Label label2(String label) => AstTestFactory.label(identifier3(label));
 
   static LabeledStatement labeledStatement(
           List<Label> labels, Statement statement) =>
       new LabeledStatement(labels, statement);
 
   static LibraryDirective libraryDirective(
           List<Annotation> metadata, LibraryIdentifier libraryName) =>
       new LibraryDirective(
           null,
           metadata,
@@ skipping 529 matching lines @@
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static YieldStatement yieldStatement(Expression expression) =>
       new YieldStatement(
           TokenFactory.tokenFromTypeAndString(TokenType.IDENTIFIER, "yield"),
           null,
           expression,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 }