Rename AstFactory -> AstTestFactory.

pkg/analyzer/lib/src/generated/testing/test_type_provider.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.test_type_provider;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart' show Source;
-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';
 
 /**
  * A type provider that can be used by tests without creating the element model
  * for the core library.
  */
 class TestTypeProvider extends TypeProviderBase {
   /**
    * The type representing the built-in type 'bool'.
    */
@@ skipping 136 matching lines @@
   InterfaceType get boolType {
     if (_boolType == null) {
       ClassElementImpl boolElement = ElementFactory.classElement2("bool");
       _boolType = boolElement.type;
       ConstructorElementImpl fromEnvironment = ElementFactory
           .constructorElement(boolElement, "fromEnvironment", true);
       fromEnvironment.parameters = <ParameterElement>[
         ElementFactory.requiredParameter2("name", stringType),
         ElementFactory.namedParameter3("defaultValue",
             type: _boolType,
-            initializer: AstFactory.booleanLiteral(false),
+            initializer: AstTestFactory.booleanLiteral(false),
             initializerCode: 'false')
       ];
       fromEnvironment.factory = true;
       fromEnvironment.isCycleFree = true;
       boolElement.constructors = <ConstructorElement>[fromEnvironment];
     }
     return _boolType;
   }
 
   @override
@@ skipping 12 matching lines @@
       FieldElementImpl expiresField = ElementFactory.fieldElement(
           'expires', false, true, false, stringType);
       deprecatedElement.fields = <FieldElement>[expiresField];
       deprecatedElement.accessors = <PropertyAccessorElement>[
         expiresField.getter
       ];
       ConstructorElementImpl constructor = ElementFactory
           .constructorElement(deprecatedElement, '', true, [stringType]);
       (constructor.parameters[0] as ParameterElementImpl).name = 'expires';
       ConstructorFieldInitializer expiresInit =
-          AstFactory.constructorFieldInitializer(
-              true, 'expires', AstFactory.identifier3('expires'));
+          AstTestFactory.constructorFieldInitializer(
+              true, 'expires', AstTestFactory.identifier3('expires'));
       expiresInit.fieldName.staticElement = expiresField;
       (expiresInit.expression as SimpleIdentifier).staticElement =
           constructor.parameters[0];
       constructor.constantInitializers = <ConstructorInitializer>[expiresInit];
       deprecatedElement.constructors = <ConstructorElement>[constructor];
       _deprecatedType = deprecatedElement.type;
     }
     return _deprecatedType;
   }
 
@@ skipping 42 matching lines @@
   }
 
   @override
   InterfaceType get futureType {
     if (_futureType == null) {
       Source asyncSource = _context.sourceFactory.forUri(DartSdk.DART_ASYNC);
       _context.setContents(asyncSource, "");
       CompilationUnitElementImpl asyncUnit =
           new CompilationUnitElementImpl("async.dart");
       LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(
-          _context, AstFactory.libraryIdentifier2(["dart.async"]));
+          _context, AstTestFactory.libraryIdentifier2(["dart.async"]));
       asyncLibrary.definingCompilationUnit = asyncUnit;
       asyncUnit.librarySource = asyncUnit.source = asyncSource;
 
       ClassElementImpl future = ElementFactory.classElement2("Future", ["T"]);
       _futureType = future.type;
       asyncUnit.types = <ClassElement>[future];
     }
     return _futureType;
   }
 
@@ skipping 330 matching lines @@
       ElementFactory.constructorElement(numElement, null, false)
         ..isSynthetic = true
     ];
     intElement.constructors = <ConstructorElement>[fromEnvironment];
     doubleElement.constructors = <ConstructorElement>[
       ElementFactory.constructorElement(doubleElement, null, false)
         ..isSynthetic = true
     ];
     ConstFieldElementImpl varINFINITY = ElementFactory.fieldElement(
         "INFINITY", true, false, true, _doubleType,
-        initializer: AstFactory.doubleLiteral(double.INFINITY));
-    varINFINITY.constantInitializer = AstFactory.binaryExpression(
-        AstFactory.integer(1), TokenType.SLASH, AstFactory.integer(0));
+        initializer: AstTestFactory.doubleLiteral(double.INFINITY));
+    varINFINITY.constantInitializer = AstTestFactory.binaryExpression(
+        AstTestFactory.integer(1), TokenType.SLASH, AstTestFactory.integer(0));
     List<FieldElement> fields = <FieldElement>[
       ElementFactory.fieldElement("NAN", true, false, true, _doubleType,
-          initializer: AstFactory.doubleLiteral(double.NAN)),
+          initializer: AstTestFactory.doubleLiteral(double.NAN)),
       varINFINITY,
       ElementFactory.fieldElement(
           "NEGATIVE_INFINITY", true, false, true, _doubleType,
-          initializer: AstFactory.doubleLiteral(double.NEGATIVE_INFINITY)),
+          initializer: AstTestFactory.doubleLiteral(double.NEGATIVE_INFINITY)),
       ElementFactory.fieldElement(
           "MIN_POSITIVE", true, false, true, _doubleType,
-          initializer: AstFactory.doubleLiteral(double.MIN_POSITIVE)),
+          initializer: AstTestFactory.doubleLiteral(double.MIN_POSITIVE)),
       ElementFactory.fieldElement("MAX_FINITE", true, false, true, _doubleType,
-          initializer: AstFactory.doubleLiteral(double.MAX_FINITE))
+          initializer: AstTestFactory.doubleLiteral(double.MAX_FINITE))
     ];
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors =
         new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
     doubleElement.methods = <MethodElement>[
@@ skipping 33 matching lines @@
    * and also set the fields to those that correspond to the accessors.
    */
   void _setAccessors(
       ClassElementImpl element, List<PropertyAccessorElement> accessors) {
     element.accessors = accessors;
     element.fields = accessors
         .map((PropertyAccessorElement accessor) => accessor.variable)
         .toList();
   }
 }