Rename AstFactory -> AstTestFactory.

pkg/analyzer/test/generated/incremental_resolver_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.incremental_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/incremental_logger.dart' as logging;
 import 'package:analyzer/src/generated/incremental_resolution_validator.dart';
 import 'package:analyzer/src/generated/incremental_resolver.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source_io.dart';
-import 'package:analyzer/src/generated/testing/ast_factory.dart';
+import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'analysis_context_factory.dart';
 import 'resolver_test_case.dart';
@@ skipping 2211 matching lines @@
   }
 
   void test_scopeFor_MethodDeclaration_body() {
     Scope scope = _scopeFor(_createResolvedMethodDeclaration().body);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionScope, FunctionScope, scope);
   }
 
   void test_scopeFor_notInCompilationUnit() {
     try {
-      _scopeFor(AstFactory.identifier3("x"));
+      _scopeFor(AstTestFactory.identifier3("x"));
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   void test_scopeFor_null() {
     try {
       _scopeFor(null);
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   void test_scopeFor_unresolved() {
     try {
-      _scopeFor(AstFactory.compilationUnit());
+      _scopeFor(AstTestFactory.compilationUnit());
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   ClassDeclaration _createResolvedClassDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
-    ClassDeclaration classNode = AstFactory.classDeclaration(
-        null, className, AstFactory.typeParameterList(), null, null, null);
+    ClassDeclaration classNode = AstTestFactory.classDeclaration(
+        null, className, AstTestFactory.typeParameterList(), null, null, null);
     unit.declarations.add(classNode);
     ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
     (unit.element as CompilationUnitElementImpl).types = <ClassElement>[
       classElement
     ];
     return classNode;
   }
 
   ClassTypeAlias _createResolvedClassTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
-    ClassTypeAlias classNode = AstFactory.classTypeAlias(
-        className, AstFactory.typeParameterList(), null, null, null, null);
+    ClassTypeAlias classNode = AstTestFactory.classTypeAlias(
+        className, AstTestFactory.typeParameterList(), null, null, null, null);
     unit.declarations.add(classNode);
     ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
     (unit.element as CompilationUnitElementImpl).types = <ClassElement>[
       classElement
     ];
     return classNode;
   }
 
   CompilationUnit _createResolvedCompilationUnit() {
-    CompilationUnit unit = AstFactory.compilationUnit();
+    CompilationUnit unit = AstTestFactory.compilationUnit();
     LibraryElementImpl library =
         ElementFactory.library(AnalysisContextFactory.contextWithCore(), "lib");
     unit.element = library.definingCompilationUnit;
     return unit;
   }
 
   ConstructorDeclaration _createResolvedConstructorDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String constructorName = "f";
-    ConstructorDeclaration constructorNode = AstFactory.constructorDeclaration(
-        AstFactory.identifier3(constructorName),
-        null,
-        AstFactory.formalParameterList(),
-        null);
+    ConstructorDeclaration constructorNode =
+        AstTestFactory.constructorDeclaration(
+            AstTestFactory.identifier3(constructorName),
+            null,
+            AstTestFactory.formalParameterList(),
+            null);
     classNode.members.add(constructorNode);
     ConstructorElement constructorElement =
         ElementFactory.constructorElement2(classNode.element, null);
     constructorNode.element = constructorElement;
     (classNode.element as ClassElementImpl).constructors = <ConstructorElement>[
       constructorElement
     ];
     return constructorNode;
   }
 
   FunctionDeclaration _createResolvedFunctionDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String functionName = "f";
-    FunctionDeclaration functionNode = AstFactory.functionDeclaration(
-        null, null, functionName, AstFactory.functionExpression());
+    FunctionDeclaration functionNode = AstTestFactory.functionDeclaration(
+        null, null, functionName, AstTestFactory.functionExpression());
     unit.declarations.add(functionNode);
     FunctionElement functionElement =
         ElementFactory.functionElement(functionName);
     functionNode.name.staticElement = functionElement;
     (unit.element as CompilationUnitElementImpl).functions = <FunctionElement>[
       functionElement
     ];
     return functionNode;
   }
 
   FunctionTypeAlias _createResolvedFunctionTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
-    FunctionTypeAlias aliasNode = AstFactory.typeAlias(
-        AstFactory.typeName4("A"),
+    FunctionTypeAlias aliasNode = AstTestFactory.typeAlias(
+        AstTestFactory.typeName4("A"),
         "F",
-        AstFactory.typeParameterList(),
-        AstFactory.formalParameterList());
+        AstTestFactory.typeParameterList(),
+        AstTestFactory.formalParameterList());
     unit.declarations.add(aliasNode);
     SimpleIdentifier aliasName = aliasNode.name;
     FunctionTypeAliasElement aliasElement =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
     aliasName.staticElement = aliasElement;
     (unit.element as CompilationUnitElementImpl).typeAliases =
         <FunctionTypeAliasElement>[aliasElement];
     return aliasNode;
   }
 
   MethodDeclaration _createResolvedMethodDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String methodName = "f";
-    MethodDeclaration methodNode = AstFactory.methodDeclaration(
+    MethodDeclaration methodNode = AstTestFactory.methodDeclaration(
         null,
         null,
         null,
         null,
-        AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList());
+        AstTestFactory.identifier3(methodName),
+        AstTestFactory.formalParameterList());
     classNode.members.add(methodNode);
     MethodElement methodElement =
         ElementFactory.methodElement(methodName, null);
     methodNode.name.staticElement = methodElement;
     (classNode.element as ClassElementImpl).methods = <MethodElement>[
       methodElement
     ];
     return methodNode;
   }
 
@@ skipping 32 matching lines @@
   void logException(Object exception, [Object stackTrace]) {
     lastException = exception;
     lastStackTrace = stackTrace;
   }
 
   @override
   logging.LoggingTimer startTimer() {
     return new logging.LoggingTimer(this);
   }
 }