Clean-up imports

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/src/generated/ast.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
@@ skipping 1479 matching lines @@
         AstFactory.identifier3("a"),
         [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_multipleStatements() {
     _assertClone(AstFactory.switchCase(
         AstFactory.identifier3("a"), [AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchCase_noLabels() {
-    _assertClone(AstFactory.switchCase(
-        AstFactory.identifier3("a"), [AstFactory.block()]));
+    _assertClone(AstFactory
+        .switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_singleLabel() {
     _assertClone(AstFactory.switchCase2([AstFactory.label2("l1")],
         AstFactory.identifier3("a"), [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleLabels() {
     _assertClone(AstFactory.switchDefault(
         [AstFactory.label2("l1"), AstFactory.label2("l2")],
         [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleStatements() {
     _assertClone(
         AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_noLabels() {
     _assertClone(AstFactory.switchDefault2([AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_singleLabel() {
-    _assertClone(AstFactory.switchDefault(
-        [AstFactory.label2("l1")], [AstFactory.block()]));
+    _assertClone(AstFactory
+        .switchDefault([AstFactory.label2("l1")], [AstFactory.block()]));
   }
 
   void test_visitSwitchStatement() {
     _assertClone(AstFactory.switchStatement(AstFactory.identifier3("a"), [
       AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]),
       AstFactory.switchDefault2([AstFactory.block()])
     ]));
   }
 
   void test_visitSymbolLiteral_multiple() {
@@ skipping 1981 matching lines @@
   }
 
   void test_classDeclaration() {
     ClassDeclaration node = AstFactory.classDeclaration(
         null,
         "A",
         AstFactory.typeParameterList(["E"]),
         AstFactory.extendsClause(AstFactory.typeName4("B")),
         AstFactory.withClause([AstFactory.typeName4("C")]),
         AstFactory.implementsClause([AstFactory.typeName4("D")]), [
-      AstFactory.fieldDeclaration2(
-          false, null, [AstFactory.variableDeclaration("f")])
+      AstFactory
+          .fieldDeclaration2(false, null, [AstFactory.variableDeclaration("f")])
     ]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
     node.nativeClause = AstFactory.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());
@@ skipping 425 matching lines @@
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression_2());
   }
 
   void test_label() {
     Label node = AstFactory.label2("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_label());
   }
 
   void test_labeledStatement() {
-    LabeledStatement node = AstFactory.labeledStatement(
-        [AstFactory.label2("l")], AstFactory.block());
+    LabeledStatement node = AstFactory
+        .labeledStatement([AstFactory.label2("l")], AstFactory.block());
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_labeledStatement(0));
     _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
   }
 
   void test_libraryDirective() {
     LibraryDirective node = AstFactory.libraryDirective2("lib");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
@@ skipping 178 matching lines @@
   }
 
   void test_switchCase() {
     SwitchCase node = AstFactory.switchCase2(
         [AstFactory.label2("l")], AstFactory.integer(0), [AstFactory.block()]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_switchCase());
     _testSwitchMember(node);
   }
 
   void test_switchDefault() {
-    SwitchDefault node = AstFactory.switchDefault(
-        [AstFactory.label2("l")], [AstFactory.block()]);
+    SwitchDefault node = AstFactory
+        .switchDefault([AstFactory.label2("l")], [AstFactory.block()]);
     _testSwitchMember(node);
   }
 
   void test_switchStatement() {
     SwitchStatement node =
         AstFactory.switchStatement(AstFactory.identifier3("x"), [
       AstFactory.switchCase2([AstFactory.label2("l")], AstFactory.integer(0),
           [AstFactory.block()]),
       AstFactory.switchDefault([AstFactory.label2("l")], [AstFactory.block()])
     ]);
@@ skipping 32 matching lines @@
   }
 
   void test_typeArgumentList() {
     TypeArgumentList node =
         AstFactory.typeArgumentList([AstFactory.typeName4("A")]);
     _assertReplace(
         node, new ListGetter_NodeReplacerTest_test_typeArgumentList(0));
   }
 
   void test_typeName() {
-    TypeName node = AstFactory.typeName4(
-        "T", [AstFactory.typeName4("E"), AstFactory.typeName4("F")]);
+    TypeName node = AstFactory
+        .typeName4("T", [AstFactory.typeName4("E"), AstFactory.typeName4("F")]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeName_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeName());
   }
 
   void test_typeParameter() {
     TypeParameter node =
         AstFactory.typeParameter2("E", AstFactory.typeName4("B"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter());
   }
@@ skipping 600 matching lines @@
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }