Removed fixed dependencies

packages/analyzer/lib/src/generated/testing/ast_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 engine.testing.ast_factory;
+library analyzer.src.generated.testing.ast_factory;
 
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/scanner.dart';
+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
  * 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'.
+ *
+ * Deprecated.  Please use [AstTestFactory] instead.
  */
+@deprecated
 class AstFactory {
   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),
           name,
-          TokenFactory.tokenFromType(TokenType.PERIOD),
+          constructorName == null
+              ? null
+              : TokenFactory.tokenFromType(TokenType.PERIOD),
           constructorName,
           arguments);
 
   static ArgumentList argumentList([List<Expression> arguments]) =>
       new ArgumentList(TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           arguments, TokenFactory.tokenFromType(TokenType.CLOSE_PAREN));
 
   static AsExpression asExpression(Expression expression, TypeName type) =>
       new AsExpression(
           expression, TokenFactory.tokenFromKeyword(Keyword.AS), type);
 
-  static AssertStatement assertStatement(Expression condition) =>
+  static AssertStatement assertStatement(Expression condition,
+          [Expression message]) =>
       new AssertStatement(
           TokenFactory.tokenFromKeyword(Keyword.ASSERT),
           TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
           condition,
+          message == null ? null : TokenFactory.tokenFromType(TokenType.COMMA),
+          message,
           TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static AssignmentExpression assignmentExpression(Expression leftHandSide,
           TokenType operator, Expression rightHandSide) =>
       new AssignmentExpression(
           leftHandSide, TokenFactory.tokenFromType(operator), rightHandSide);
 
   static BlockFunctionBody asyncBlockFunctionBody(
           [List<Statement> statements]) =>
@@ skipping 360 matching lines @@
     return enumDeclaration(identifier3(name), constants);
   }
 
   static ExportDirective exportDirective(List<Annotation> metadata, String uri,
           [List<Combinator> combinators]) =>
       new ExportDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.EXPORT),
           string2(uri),
+          null,
           combinators,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ExportDirective exportDirective2(String uri,
           [List<Combinator> combinators]) =>
       exportDirective(null, uri, combinators);
 
   static ExpressionFunctionBody expressionFunctionBody(Expression expression) =>
       new ExpressionFunctionBody(
           null,
@@ skipping 206 matching lines @@
           TokenFactory.tokenFromKeyword(Keyword.IMPLEMENTS), types);
 
   static ImportDirective importDirective(
           List<Annotation> metadata, String uri, bool isDeferred, String prefix,
           [List<Combinator> combinators]) =>
       new ImportDirective(
           null,
           metadata,
           TokenFactory.tokenFromKeyword(Keyword.IMPORT),
           string2(uri),
+          null,
           !isDeferred ? null : TokenFactory.tokenFromKeyword(Keyword.DEFERRED),
           prefix == null ? null : TokenFactory.tokenFromKeyword(Keyword.AS),
           prefix == null ? null : identifier3(prefix),
           combinators,
           TokenFactory.tokenFromType(TokenType.SEMICOLON));
 
   static ImportDirective importDirective2(
           String uri, bool isDeferred, String prefix,
           [List<Combinator> combinators]) =>
       importDirective(null, uri, isDeferred, prefix, combinators);
@@ skipping 117 matching lines @@
           entries,
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
 
   static MapLiteral mapLiteral2([List<MapLiteralEntry> entries]) =>
       mapLiteral(null, null, entries);
 
   static MapLiteralEntry mapLiteralEntry(String key, Expression value) =>
       new MapLiteralEntry(
           string2(key), TokenFactory.tokenFromType(TokenType.COLON), value);
 
+  static MapLiteralEntry mapLiteralEntry2(Expression key, Expression value) =>
+      new MapLiteralEntry(
+          key, TokenFactory.tokenFromType(TokenType.COLON), value);
+
   static MethodDeclaration methodDeclaration(
           Keyword modifier,
           TypeName returnType,
           Keyword property,
           Keyword operator,
           SimpleIdentifier name,
           FormalParameterList parameters) =>
       new MethodDeclaration(
           null,
           null,
@@ skipping 43 matching lines @@
           null,
           modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
           returnType,
           property == null ? null : TokenFactory.tokenFromKeyword(property),
           operator == null ? null : TokenFactory.tokenFromKeyword(operator),
           name,
           typeParameters,
           parameters,
           body);
 
+  static MethodDeclaration methodDeclaration4(
+          {bool external: false,
+          Keyword modifier,
+          TypeName returnType,
+          Keyword property,
+          bool operator: false,
+          String name,
+          FormalParameterList parameters,
+          FunctionBody body}) =>
+      new MethodDeclaration(
+          null,
+          null,
+          external ? TokenFactory.tokenFromKeyword(Keyword.EXTERNAL) : null,
+          modifier == null ? null : TokenFactory.tokenFromKeyword(modifier),
+          returnType,
+          property == null ? null : TokenFactory.tokenFromKeyword(property),
+          operator ? TokenFactory.tokenFromKeyword(Keyword.OPERATOR) : null,
+          identifier3(name),
+          null,
+          parameters,
+          body);
+
   static MethodInvocation methodInvocation(Expression target, String methodName,
           [List<Expression> arguments,
           TokenType operator = TokenType.PERIOD]) =>
       new MethodInvocation(
           target,
           target == null ? null : TokenFactory.tokenFromType(operator),
           identifier3(methodName),
           null,
           argumentList(arguments));
 
@@ skipping 381 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));
 }