New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/ast_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.ast_test;
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 699 matching lines @@
   static final AssignmentKind BINARY = new AssignmentKind('BINARY', 0);
   static final AssignmentKind COMPOUND_LEFT = new AssignmentKind('COMPOUND_LEFT', 1);
   static final AssignmentKind COMPOUND_RIGHT = new AssignmentKind('COMPOUND_RIGHT', 2);
   static final AssignmentKind POSTFIX_INC = new AssignmentKind('POSTFIX_INC', 3);
   static final AssignmentKind PREFIX_DEC = new AssignmentKind('PREFIX_DEC', 4);
   static final AssignmentKind PREFIX_INC = new AssignmentKind('PREFIX_INC', 5);
   static final AssignmentKind PREFIX_NOT = new AssignmentKind('PREFIX_NOT', 6);
   static final AssignmentKind SIMPLE_LEFT = new AssignmentKind('SIMPLE_LEFT', 7);
   static final AssignmentKind SIMPLE_RIGHT = new AssignmentKind('SIMPLE_RIGHT', 8);
   static final AssignmentKind NONE = new AssignmentKind('NONE', 9);
-  static final List<AssignmentKind> values = [BINARY, COMPOUND_LEFT, COMPOUND_RIGHT, POSTFIX_INC, PREFIX_DEC, PREFIX_INC, PREFIX_NOT, SIMPLE_LEFT, SIMPLE_RIGHT, NONE];
+  static final List<AssignmentKind> values = [
+      BINARY,
+      COMPOUND_LEFT,
+      COMPOUND_RIGHT,
+      POSTFIX_INC,
+      PREFIX_DEC,
+      PREFIX_INC,
+      PREFIX_NOT,
+      SIMPLE_LEFT,
+      SIMPLE_RIGHT,
+      NONE];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
   AssignmentKind(this.name, this.ordinal);
   int compareTo(AssignmentKind other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 class WrapperKind implements Comparable<WrapperKind> {
   static final WrapperKind PREFIXED_LEFT = new WrapperKind('PREFIXED_LEFT', 0);
   static final WrapperKind PREFIXED_RIGHT = new WrapperKind('PREFIXED_RIGHT', 1);
   static final WrapperKind PROPERTY_LEFT = new WrapperKind('PROPERTY_LEFT', 2);
   static final WrapperKind PROPERTY_RIGHT = new WrapperKind('PROPERTY_RIGHT', 3);
   static final WrapperKind NONE = new WrapperKind('NONE', 4);
-  static final List<WrapperKind> values = [PREFIXED_LEFT, PREFIXED_RIGHT, PROPERTY_LEFT, PROPERTY_RIGHT, NONE];
+  static final List<WrapperKind> values = [
+      PREFIXED_LEFT,
+      PREFIXED_RIGHT,
+      PROPERTY_LEFT,
+      PROPERTY_RIGHT,
+      NONE];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
   WrapperKind(this.name, this.ordinal);
   int compareTo(WrapperKind other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 class BreadthFirstVisitorTest extends ParserTestCase {
   void testIt() {
-    String source = EngineTestCase.createSource(["class A {", "  bool get g => true;", "}", "class B {", "  int f() {", "    num q() {", "      return 3;", "    }", "  return q() + 4;", "  }", "}", "A f(var p) {", "  if ((p as A).g) {", "    return p;", "  } else {", "    return null;", "  }", "}"]);
+    String source = EngineTestCase.createSource([
+        "class A {",
+        "  bool get g => true;",
+        "}",
+        "class B {",
+        "  int f() {",
+        "    num q() {",
+        "      return 3;",
+        "    }",
+        "  return q() + 4;",
+        "  }",
+        "}",
+        "A f(var p) {",
+        "  if ((p as A).g) {",
+        "    return p;",
+        "  } else {",
+        "    return null;",
+        "  }",
+        "}"]);
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(source, []);
     List<ASTNode> nodes = new List<ASTNode>();
     BreadthFirstVisitor<Object> visitor = new BreadthFirstVisitor_15(nodes);
     visitor.visitAllNodes(unit);
     EngineTestCase.assertSize(59, nodes);
     EngineTestCase.assertInstanceOf(CompilationUnit, nodes[0]);
     EngineTestCase.assertInstanceOf(ClassDeclaration, nodes[2]);
     EngineTestCase.assertInstanceOf(FunctionDeclaration, nodes[3]);
     EngineTestCase.assertInstanceOf(FunctionDeclarationStatement, nodes[27]);
     EngineTestCase.assertInstanceOf(IntegerLiteral, nodes[58]);
@@ skipping 517 matching lines @@
   void test_visitBooleanLiteral_true() {
     assertSource("true", ASTFactory.booleanLiteral(true));
   }
   void test_visitBreakStatement_label() {
     assertSource("break l;", ASTFactory.breakStatement2("l"));
   }
   void test_visitBreakStatement_noLabel() {
     assertSource("break;", ASTFactory.breakStatement());
   }
   void test_visitCascadeExpression_field() {
-    assertSource("a..b..c", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [ASTFactory.cascadedPropertyAccess("b"), ASTFactory.cascadedPropertyAccess("c")]));
+    assertSource("a..b..c", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [
+        ASTFactory.cascadedPropertyAccess("b"),
+        ASTFactory.cascadedPropertyAccess("c")]));
   }
   void test_visitCascadeExpression_index() {
-    assertSource("a..[0]..[1]", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [ASTFactory.cascadedIndexExpression(ASTFactory.integer(0)), ASTFactory.cascadedIndexExpression(ASTFactory.integer(1))]));
+    assertSource("a..[0]..[1]", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [
+        ASTFactory.cascadedIndexExpression(ASTFactory.integer(0)),
+        ASTFactory.cascadedIndexExpression(ASTFactory.integer(1))]));
   }
   void test_visitCascadeExpression_method() {
-    assertSource("a..b()..c()", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [ASTFactory.cascadedMethodInvocation("b", []), ASTFactory.cascadedMethodInvocation("c", [])]));
+    assertSource("a..b()..c()", ASTFactory.cascadeExpression(ASTFactory.identifier3("a"), [
+        ASTFactory.cascadedMethodInvocation("b", []),
+        ASTFactory.cascadedMethodInvocation("c", [])]));
   }
   void test_visitCatchClause_catch_noStack() {
     assertSource("catch (e) {}", ASTFactory.catchClause("e", []));
   }
   void test_visitCatchClause_catch_stack() {
     assertSource("catch (e, s) {}", ASTFactory.catchClause2("e", "s", []));
   }
   void test_visitCatchClause_on() {
     assertSource("on E {}", ASTFactory.catchClause3(ASTFactory.typeName4("E", []), []));
   }
@@ skipping 15 matching lines @@
   void test_visitClassDeclaration_extends_with() {
     assertSource("class C extends A with M {}", ASTFactory.classDeclaration(null, "C", null, ASTFactory.extendsClause(ASTFactory.typeName4("A", [])), ASTFactory.withClause([ASTFactory.typeName4("M", [])]), null, []));
   }
   void test_visitClassDeclaration_extends_with_implements() {
     assertSource("class C extends A with M implements B {}", ASTFactory.classDeclaration(null, "C", null, ASTFactory.extendsClause(ASTFactory.typeName4("A", [])), ASTFactory.withClause([ASTFactory.typeName4("M", [])]), ASTFactory.implementsClause([ASTFactory.typeName4("B", [])]), []));
   }
   void test_visitClassDeclaration_implements() {
     assertSource("class C implements B {}", ASTFactory.classDeclaration(null, "C", null, null, null, ASTFactory.implementsClause([ASTFactory.typeName4("B", [])]), []));
   }
   void test_visitClassDeclaration_multipleMember() {
-    assertSource("class C {var a; var b;}", ASTFactory.classDeclaration(null, "C", null, null, null, null, [ASTFactory.fieldDeclaration2(false, Keyword.VAR, [ASTFactory.variableDeclaration("a")]), ASTFactory.fieldDeclaration2(false, Keyword.VAR, [ASTFactory.variableDeclaration("b")])]));
+    assertSource("class C {var a; var b;}", ASTFactory.classDeclaration(null, "C", null, null, null, null, [
+        ASTFactory.fieldDeclaration2(false, Keyword.VAR, [ASTFactory.variableDeclaration("a")]),
+        ASTFactory.fieldDeclaration2(false, Keyword.VAR, [ASTFactory.variableDeclaration("b")])]));
   }
   void test_visitClassDeclaration_parameters() {
     assertSource("class C<E> {}", ASTFactory.classDeclaration(null, "C", ASTFactory.typeParameterList(["E"]), null, null, null, []));
   }
   void test_visitClassDeclaration_parameters_extends() {
     assertSource("class C<E> extends A {}", ASTFactory.classDeclaration(null, "C", ASTFactory.typeParameterList(["E"]), ASTFactory.extendsClause(ASTFactory.typeName4("A", [])), null, null, []));
   }
   void test_visitClassDeclaration_parameters_extends_implements() {
     assertSource("class C<E> extends A implements B {}", ASTFactory.classDeclaration(null, "C", ASTFactory.typeParameterList(["E"]), ASTFactory.extendsClause(ASTFactory.typeName4("A", [])), null, ASTFactory.implementsClause([ASTFactory.typeName4("B", [])]), []));
   }
@@ skipping 69 matching lines @@
   void test_visitConstructorDeclaration_const() {
     assertSource("const C() {}", ASTFactory.constructorDeclaration2(Keyword.CONST, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorDeclaration_external() {
     assertSource("external C();", ASTFactory.constructorDeclaration(ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), null));
   }
   void test_visitConstructorDeclaration_minimal() {
     assertSource("C() {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorDeclaration_multipleInitializers() {
-    assertSource("C() : a = b, c = d {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), ASTFactory.list([(ASTFactory.constructorFieldInitializer(false, "a", ASTFactory.identifier3("b")) as ConstructorInitializer), ASTFactory.constructorFieldInitializer(false, "c", ASTFactory.identifier3("d"))]), ASTFactory.blockFunctionBody([])));
+    assertSource("C() : a = b, c = d {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), ASTFactory.list([
+        (ASTFactory.constructorFieldInitializer(false, "a", ASTFactory.identifier3("b")) as ConstructorInitializer),
+        ASTFactory.constructorFieldInitializer(false, "c", ASTFactory.identifier3("d"))]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorDeclaration_multipleParameters() {
-    assertSource("C(var a, var b) {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter(Keyword.VAR, "a"), ASTFactory.simpleFormalParameter(Keyword.VAR, "b")]), null, ASTFactory.blockFunctionBody([])));
+    assertSource("C(var a, var b) {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter(Keyword.VAR, "a"),
+        ASTFactory.simpleFormalParameter(Keyword.VAR, "b")]), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorDeclaration_named() {
     assertSource("C.m() {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), "m", ASTFactory.formalParameterList([]), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorDeclaration_singleInitializer() {
     assertSource("C() : a = b {}", ASTFactory.constructorDeclaration2(null, null, ASTFactory.identifier3("C"), null, ASTFactory.formalParameterList([]), ASTFactory.list([(ASTFactory.constructorFieldInitializer(false, "a", ASTFactory.identifier3("b")) as ConstructorInitializer)]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitConstructorFieldInitializer_withoutThis() {
     assertSource("a = b", ASTFactory.constructorFieldInitializer(false, "a", ASTFactory.identifier3("b")));
   }
@@ skipping 36 matching lines @@
   void test_visitEmptyFunctionBody() {
     assertSource(";", ASTFactory.emptyFunctionBody());
   }
   void test_visitEmptyStatement() {
     assertSource(";", ASTFactory.emptyStatement());
   }
   void test_visitExportDirective_combinator() {
     assertSource("export 'a.dart' show A;", ASTFactory.exportDirective2("a.dart", [(ASTFactory.showCombinator([ASTFactory.identifier3("A")]) as Combinator)]));
   }
   void test_visitExportDirective_combinators() {
-    assertSource("export 'a.dart' show A hide B;", ASTFactory.exportDirective2("a.dart", [ASTFactory.showCombinator([ASTFactory.identifier3("A")]), ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
+    assertSource("export 'a.dart' show A hide B;", ASTFactory.exportDirective2("a.dart", [
+        ASTFactory.showCombinator([ASTFactory.identifier3("A")]),
+        ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
   }
   void test_visitExportDirective_minimal() {
     assertSource("export 'a.dart';", ASTFactory.exportDirective2("a.dart", []));
   }
   void test_visitExpressionFunctionBody() {
     assertSource("=> a;", ASTFactory.expressionFunctionBody(ASTFactory.identifier3("a")));
   }
   void test_visitExpressionStatement() {
     assertSource("a;", ASTFactory.expressionStatement(ASTFactory.identifier3("a")));
   }
@@ skipping 21 matching lines @@
   void test_visitForEachStatement() {
     assertSource("for (a in b) {}", ASTFactory.forEachStatement(ASTFactory.declaredIdentifier3("a"), ASTFactory.identifier3("b"), ASTFactory.block([])));
   }
   void test_visitFormalParameterList_empty() {
     assertSource("()", ASTFactory.formalParameterList([]));
   }
   void test_visitFormalParameterList_n() {
     assertSource("({a : 0})", ASTFactory.formalParameterList([ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0))]));
   }
   void test_visitFormalParameterList_nn() {
-    assertSource("({a : 0, b : 1})", ASTFactory.formalParameterList([ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0)), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
+    assertSource("({a : 0, b : 1})", ASTFactory.formalParameterList([
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0)),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
   }
   void test_visitFormalParameterList_p() {
     assertSource("([a = 0])", ASTFactory.formalParameterList([ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0))]));
   }
   void test_visitFormalParameterList_pp() {
-    assertSource("([a = 0, b = 1])", ASTFactory.formalParameterList([ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0)), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
+    assertSource("([a = 0, b = 1])", ASTFactory.formalParameterList([
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("a"), ASTFactory.integer(0)),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
   }
   void test_visitFormalParameterList_r() {
     assertSource("(a)", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a")]));
   }
   void test_visitFormalParameterList_rn() {
-    assertSource("(a, {b : 1})", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
+    assertSource("(a, {b : 1})", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
   }
   void test_visitFormalParameterList_rnn() {
-    assertSource("(a, {b : 1, c : 2})", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1)), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(2))]));
+    assertSource("(a, {b : 1, c : 2})", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1)),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(2))]));
   }
   void test_visitFormalParameterList_rp() {
-    assertSource("(a, [b = 1])", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
+    assertSource("(a, [b = 1])", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1))]));
   }
   void test_visitFormalParameterList_rpp() {
-    assertSource("(a, [b = 1, c = 2])", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1)), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(2))]));
+    assertSource("(a, [b = 1, c = 2])", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("b"), ASTFactory.integer(1)),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(2))]));
   }
   void test_visitFormalParameterList_rr() {
-    assertSource("(a, b)", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.simpleFormalParameter3("b")]));
+    assertSource("(a, b)", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.simpleFormalParameter3("b")]));
   }
   void test_visitFormalParameterList_rrn() {
-    assertSource("(a, b, {c : 3})", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.simpleFormalParameter3("b"), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3))]));
+    assertSource("(a, b, {c : 3})", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.simpleFormalParameter3("b"),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3))]));
   }
   void test_visitFormalParameterList_rrnn() {
-    assertSource("(a, b, {c : 3, d : 4})", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.simpleFormalParameter3("b"), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3)), ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("d"), ASTFactory.integer(4))]));
+    assertSource("(a, b, {c : 3, d : 4})", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.simpleFormalParameter3("b"),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3)),
+        ASTFactory.namedFormalParameter(ASTFactory.simpleFormalParameter3("d"), ASTFactory.integer(4))]));
   }
   void test_visitFormalParameterList_rrp() {
-    assertSource("(a, b, [c = 3])", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.simpleFormalParameter3("b"), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3))]));
+    assertSource("(a, b, [c = 3])", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.simpleFormalParameter3("b"),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3))]));
   }
   void test_visitFormalParameterList_rrpp() {
-    assertSource("(a, b, [c = 3, d = 4])", ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter3("a"), ASTFactory.simpleFormalParameter3("b"), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3)), ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("d"), ASTFactory.integer(4))]));
+    assertSource("(a, b, [c = 3, d = 4])", ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter3("a"),
+        ASTFactory.simpleFormalParameter3("b"),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("c"), ASTFactory.integer(3)),
+        ASTFactory.positionalFormalParameter(ASTFactory.simpleFormalParameter3("d"), ASTFactory.integer(4))]));
   }
   void test_visitForStatement_c() {
     assertSource("for (; c;) {}", ASTFactory.forStatement((null as Expression), ASTFactory.identifier3("c"), null, ASTFactory.block([])));
   }
   void test_visitForStatement_cu() {
     assertSource("for (; c; u) {}", ASTFactory.forStatement((null as Expression), ASTFactory.identifier3("c"), ASTFactory.list([(ASTFactory.identifier3("u") as Expression)]), ASTFactory.block([])));
   }
   void test_visitForStatement_e() {
     assertSource("for (e;;) {}", ASTFactory.forStatement(ASTFactory.identifier3("e"), null, null, ASTFactory.block([])));
   }
@@ skipping 45 matching lines @@
   void test_visitFunctionTypedFormalParameter_type() {
     assertSource("T f()", ASTFactory.functionTypedFormalParameter(ASTFactory.typeName4("T", []), "f", []));
   }
   void test_visitIfStatement_withElse() {
     assertSource("if (c) {} else {}", ASTFactory.ifStatement2(ASTFactory.identifier3("c"), ASTFactory.block([]), ASTFactory.block([])));
   }
   void test_visitIfStatement_withoutElse() {
     assertSource("if (c) {}", ASTFactory.ifStatement(ASTFactory.identifier3("c"), ASTFactory.block([])));
   }
   void test_visitImplementsClause_multiple() {
-    assertSource("implements A, B", ASTFactory.implementsClause([ASTFactory.typeName4("A", []), ASTFactory.typeName4("B", [])]));
+    assertSource("implements A, B", ASTFactory.implementsClause([
+        ASTFactory.typeName4("A", []),
+        ASTFactory.typeName4("B", [])]));
   }
   void test_visitImplementsClause_single() {
     assertSource("implements A", ASTFactory.implementsClause([ASTFactory.typeName4("A", [])]));
   }
   void test_visitImportDirective_combinator() {
     assertSource("import 'a.dart' show A;", ASTFactory.importDirective2("a.dart", null, [ASTFactory.showCombinator([ASTFactory.identifier3("A")])]));
   }
   void test_visitImportDirective_combinators() {
-    assertSource("import 'a.dart' show A hide B;", ASTFactory.importDirective2("a.dart", null, [ASTFactory.showCombinator([ASTFactory.identifier3("A")]), ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
+    assertSource("import 'a.dart' show A hide B;", ASTFactory.importDirective2("a.dart", null, [
+        ASTFactory.showCombinator([ASTFactory.identifier3("A")]),
+        ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
   }
   void test_visitImportDirective_minimal() {
     assertSource("import 'a.dart';", ASTFactory.importDirective2("a.dart", null, []));
   }
   void test_visitImportDirective_prefix() {
     assertSource("import 'a.dart' as p;", ASTFactory.importDirective2("a.dart", "p", []));
   }
   void test_visitImportDirective_prefix_combinator() {
     assertSource("import 'a.dart' as p show A;", ASTFactory.importDirective2("a.dart", "p", [ASTFactory.showCombinator([ASTFactory.identifier3("A")])]));
   }
   void test_visitImportDirective_prefix_combinators() {
-    assertSource("import 'a.dart' as p show A hide B;", ASTFactory.importDirective2("a.dart", "p", [ASTFactory.showCombinator([ASTFactory.identifier3("A")]), ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
+    assertSource("import 'a.dart' as p show A hide B;", ASTFactory.importDirective2("a.dart", "p", [
+        ASTFactory.showCombinator([ASTFactory.identifier3("A")]),
+        ASTFactory.hideCombinator([ASTFactory.identifier3("B")])]));
   }
   void test_visitImportHideCombinator_multiple() {
     assertSource("hide a, b", ASTFactory.hideCombinator([ASTFactory.identifier3("a"), ASTFactory.identifier3("b")]));
   }
   void test_visitImportHideCombinator_single() {
     assertSource("hide a", ASTFactory.hideCombinator([ASTFactory.identifier3("a")]));
   }
   void test_visitImportShowCombinator_multiple() {
     assertSource("show a, b", ASTFactory.showCombinator([ASTFactory.identifier3("a"), ASTFactory.identifier3("b")]));
   }
@@ skipping 36 matching lines @@
   void test_visitLabeledStatement_multiple() {
     assertSource("a: b: return;", ASTFactory.labeledStatement(ASTFactory.list([ASTFactory.label2("a"), ASTFactory.label2("b")]), ASTFactory.returnStatement()));
   }
   void test_visitLabeledStatement_single() {
     assertSource("a: return;", ASTFactory.labeledStatement(ASTFactory.list([ASTFactory.label2("a")]), ASTFactory.returnStatement()));
   }
   void test_visitLibraryDirective() {
     assertSource("library l;", ASTFactory.libraryDirective2("l"));
   }
   void test_visitLibraryIdentifier_multiple() {
-    assertSource("a.b.c", ASTFactory.libraryIdentifier([ASTFactory.identifier3("a"), ASTFactory.identifier3("b"), ASTFactory.identifier3("c")]));
+    assertSource("a.b.c", ASTFactory.libraryIdentifier([
+        ASTFactory.identifier3("a"),
+        ASTFactory.identifier3("b"),
+        ASTFactory.identifier3("c")]));
   }
   void test_visitLibraryIdentifier_single() {
     assertSource("a", ASTFactory.libraryIdentifier([ASTFactory.identifier3("a")]));
   }
   void test_visitListLiteral_const() {
     assertSource("const []", ASTFactory.listLiteral2(Keyword.CONST, null, []));
   }
   void test_visitListLiteral_empty() {
     assertSource("[]", ASTFactory.listLiteral([]));
   }
   void test_visitListLiteral_nonEmpty() {
-    assertSource("[a, b, c]", ASTFactory.listLiteral([ASTFactory.identifier3("a"), ASTFactory.identifier3("b"), ASTFactory.identifier3("c")]));
+    assertSource("[a, b, c]", ASTFactory.listLiteral([
+        ASTFactory.identifier3("a"),
+        ASTFactory.identifier3("b"),
+        ASTFactory.identifier3("c")]));
   }
   void test_visitMapLiteral_const() {
     assertSource("const {}", ASTFactory.mapLiteral(Keyword.CONST, null, []));
   }
   void test_visitMapLiteral_empty() {
     assertSource("{}", ASTFactory.mapLiteral2([]));
   }
   void test_visitMapLiteral_nonEmpty() {
-    assertSource("{'a' : a, 'b' : b, 'c' : c}", ASTFactory.mapLiteral2([ASTFactory.mapLiteralEntry("a", ASTFactory.identifier3("a")), ASTFactory.mapLiteralEntry("b", ASTFactory.identifier3("b")), ASTFactory.mapLiteralEntry("c", ASTFactory.identifier3("c"))]));
+    assertSource("{'a' : a, 'b' : b, 'c' : c}", ASTFactory.mapLiteral2([
+        ASTFactory.mapLiteralEntry("a", ASTFactory.identifier3("a")),
+        ASTFactory.mapLiteralEntry("b", ASTFactory.identifier3("b")),
+        ASTFactory.mapLiteralEntry("c", ASTFactory.identifier3("c"))]));
   }
   void test_visitMapLiteralEntry() {
     assertSource("'a' : b", ASTFactory.mapLiteralEntry("a", ASTFactory.identifier3("b")));
   }
   void test_visitMethodDeclaration_external() {
     assertSource("external m();", ASTFactory.methodDeclaration(null, null, null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([])));
   }
   void test_visitMethodDeclaration_external_returnType() {
     assertSource("external T m();", ASTFactory.methodDeclaration(null, ASTFactory.typeName4("T", []), null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([])));
   }
   void test_visitMethodDeclaration_getter() {
     assertSource("get m {}", ASTFactory.methodDeclaration2(null, null, Keyword.GET, null, ASTFactory.identifier3("m"), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_getter_returnType() {
     assertSource("T get m {}", ASTFactory.methodDeclaration2(null, ASTFactory.typeName4("T", []), Keyword.GET, null, ASTFactory.identifier3("m"), null, ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_getter_seturnType() {
     assertSource("T set m(var v) {}", ASTFactory.methodDeclaration2(null, ASTFactory.typeName4("T", []), Keyword.SET, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter(Keyword.VAR, "v")]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_minimal() {
     assertSource("m() {}", ASTFactory.methodDeclaration2(null, null, null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_multipleParameters() {
-    assertSource("m(var a, var b) {}", ASTFactory.methodDeclaration2(null, null, null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([ASTFactory.simpleFormalParameter(Keyword.VAR, "a"), ASTFactory.simpleFormalParameter(Keyword.VAR, "b")]), ASTFactory.blockFunctionBody([])));
+    assertSource("m(var a, var b) {}", ASTFactory.methodDeclaration2(null, null, null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([
+        ASTFactory.simpleFormalParameter(Keyword.VAR, "a"),
+        ASTFactory.simpleFormalParameter(Keyword.VAR, "b")]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_operator() {
     assertSource("operator +() {}", ASTFactory.methodDeclaration2(null, null, null, Keyword.OPERATOR, ASTFactory.identifier3("+"), ASTFactory.formalParameterList([]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_operator_returnType() {
     assertSource("T operator +() {}", ASTFactory.methodDeclaration2(null, ASTFactory.typeName4("T", []), null, Keyword.OPERATOR, ASTFactory.identifier3("+"), ASTFactory.formalParameterList([]), ASTFactory.blockFunctionBody([])));
   }
   void test_visitMethodDeclaration_returnType() {
     assertSource("T m() {}", ASTFactory.methodDeclaration2(null, ASTFactory.typeName4("T", []), null, null, ASTFactory.identifier3("m"), ASTFactory.formalParameterList([]), ASTFactory.blockFunctionBody([])));
   }
@@ skipping 73 matching lines @@
   void test_visitSimpleFormalParameter_type() {
     assertSource("A a", ASTFactory.simpleFormalParameter4(ASTFactory.typeName4("A", []), "a"));
   }
   void test_visitSimpleIdentifier() {
     assertSource("a", ASTFactory.identifier3("a"));
   }
   void test_visitSimpleStringLiteral() {
     assertSource("'a'", ASTFactory.string2("a"));
   }
   void test_visitStringInterpolation() {
-    assertSource("'a\${e}b'", ASTFactory.string([ASTFactory.interpolationString("'a", "a"), ASTFactory.interpolationExpression(ASTFactory.identifier3("e")), ASTFactory.interpolationString("b'", "b")]));
+    assertSource("'a\${e}b'", ASTFactory.string([
+        ASTFactory.interpolationString("'a", "a"),
+        ASTFactory.interpolationExpression(ASTFactory.identifier3("e")),
+        ASTFactory.interpolationString("b'", "b")]));
   }
   void test_visitSuperConstructorInvocation() {
     assertSource("super()", ASTFactory.superConstructorInvocation([]));
   }
   void test_visitSuperConstructorInvocation_named() {
     assertSource("super.c()", ASTFactory.superConstructorInvocation2("c", []));
   }
   void test_visitSuperExpression() {
     assertSource("super", ASTFactory.superExpression());
   }
@@ skipping 15 matching lines @@
   void test_visitSwitchDefault_multipleStatements() {
     assertSource("default: {} {}", ASTFactory.switchDefault2([ASTFactory.block([]), ASTFactory.block([])]));
   }
   void test_visitSwitchDefault_noLabels() {
     assertSource("default: {}", ASTFactory.switchDefault2([ASTFactory.block([])]));
   }
   void test_visitSwitchDefault_singleLabel() {
     assertSource("l1: default: {}", ASTFactory.switchDefault(ASTFactory.list([ASTFactory.label2("l1")]), [ASTFactory.block([])]));
   }
   void test_visitSwitchStatement() {
-    assertSource("switch (a) {case 'b': {} default: {}}", ASTFactory.switchStatement(ASTFactory.identifier3("a"), [ASTFactory.switchCase(ASTFactory.string2("b"), [ASTFactory.block([])]), ASTFactory.switchDefault2([ASTFactory.block([])])]));
+    assertSource("switch (a) {case 'b': {} default: {}}", ASTFactory.switchStatement(ASTFactory.identifier3("a"), [
+        ASTFactory.switchCase(ASTFactory.string2("b"), [ASTFactory.block([])]),
+        ASTFactory.switchDefault2([ASTFactory.block([])])]));
   }
   void test_visitSymbolLiteral_multiple() {
     assertSource("#a.b.c", ASTFactory.symbolLiteral(["a", "b", "c"]));
   }
   void test_visitSymbolLiteral_single() {
     assertSource("#a", ASTFactory.symbolLiteral(["a"]));
   }
   void test_visitThisExpression() {
     assertSource("this", ASTFactory.thisExpression());
   }
   void test_visitThrowStatement() {
     assertSource("throw e", ASTFactory.throwExpression2(ASTFactory.identifier3("e")));
   }
   void test_visitTopLevelVariableDeclaration_multiple() {
     assertSource("var a;", ASTFactory.topLevelVariableDeclaration2(Keyword.VAR, [ASTFactory.variableDeclaration("a")]));
   }
   void test_visitTopLevelVariableDeclaration_single() {
-    assertSource("var a, b;", ASTFactory.topLevelVariableDeclaration2(Keyword.VAR, [ASTFactory.variableDeclaration("a"), ASTFactory.variableDeclaration("b")]));
+    assertSource("var a, b;", ASTFactory.topLevelVariableDeclaration2(Keyword.VAR, [
+        ASTFactory.variableDeclaration("a"),
+        ASTFactory.variableDeclaration("b")]));
   }
   void test_visitTryStatement_catch() {
     assertSource("try {} on E {}", ASTFactory.tryStatement2(ASTFactory.block([]), [ASTFactory.catchClause3(ASTFactory.typeName4("E", []), [])]));
   }
   void test_visitTryStatement_catches() {
-    assertSource("try {} on E {} on F {}", ASTFactory.tryStatement2(ASTFactory.block([]), [ASTFactory.catchClause3(ASTFactory.typeName4("E", []), []), ASTFactory.catchClause3(ASTFactory.typeName4("F", []), [])]));
+    assertSource("try {} on E {} on F {}", ASTFactory.tryStatement2(ASTFactory.block([]), [
+        ASTFactory.catchClause3(ASTFactory.typeName4("E", []), []),
+        ASTFactory.catchClause3(ASTFactory.typeName4("F", []), [])]));
   }
   void test_visitTryStatement_catchFinally() {
     assertSource("try {} on E {} finally {}", ASTFactory.tryStatement3(ASTFactory.block([]), ASTFactory.list([ASTFactory.catchClause3(ASTFactory.typeName4("E", []), [])]), ASTFactory.block([])));
   }
   void test_visitTryStatement_finally() {
     assertSource("try {} finally {}", ASTFactory.tryStatement(ASTFactory.block([]), ASTFactory.block([])));
   }
   void test_visitTypeAlias_generic() {
     assertSource("typedef A F<B>();", ASTFactory.typeAlias(ASTFactory.typeName4("A", []), "F", ASTFactory.typeParameterList(["B"]), ASTFactory.formalParameterList([])));
   }
   void test_visitTypeAlias_nonGeneric() {
     assertSource("typedef A F();", ASTFactory.typeAlias(ASTFactory.typeName4("A", []), "F", null, ASTFactory.formalParameterList([])));
   }
   void test_visitTypeArgumentList_multiple() {
-    assertSource("<E, F>", ASTFactory.typeArgumentList([ASTFactory.typeName4("E", []), ASTFactory.typeName4("F", [])]));
+    assertSource("<E, F>", ASTFactory.typeArgumentList([
+        ASTFactory.typeName4("E", []),
+        ASTFactory.typeName4("F", [])]));
   }
   void test_visitTypeArgumentList_single() {
     assertSource("<E>", ASTFactory.typeArgumentList([ASTFactory.typeName4("E", [])]));
   }
   void test_visitTypeName_multipleArgs() {
-    assertSource("C<D, E>", ASTFactory.typeName4("C", [ASTFactory.typeName4("D", []), ASTFactory.typeName4("E", [])]));
+    assertSource("C<D, E>", ASTFactory.typeName4("C", [
+        ASTFactory.typeName4("D", []),
+        ASTFactory.typeName4("E", [])]));
   }
   void test_visitTypeName_nestedArg() {
     assertSource("C<D<E>>", ASTFactory.typeName4("C", [ASTFactory.typeName4("D", [ASTFactory.typeName4("E", [])])]));
   }
   void test_visitTypeName_noArgs() {
     assertSource("C", ASTFactory.typeName4("C", []));
   }
   void test_visitTypeName_singleArg() {
     assertSource("C<D>", ASTFactory.typeName4("C", [ASTFactory.typeName4("D", [])]));
   }
   void test_visitTypeParameter_withExtends() {
     assertSource("E extends C", ASTFactory.typeParameter2("E", ASTFactory.typeName4("C", [])));
   }
   void test_visitTypeParameter_withoutExtends() {
     assertSource("E", ASTFactory.typeParameter("E"));
   }
   void test_visitTypeParameterList_multiple() {
     assertSource("<E, F>", ASTFactory.typeParameterList(["E", "F"]));
   }
   void test_visitTypeParameterList_single() {
     assertSource("<E>", ASTFactory.typeParameterList(["E"]));
   }
   void test_visitVariableDeclaration_initialized() {
     assertSource("a = b", ASTFactory.variableDeclaration2("a", ASTFactory.identifier3("b")));
   }
   void test_visitVariableDeclaration_uninitialized() {
     assertSource("a", ASTFactory.variableDeclaration("a"));
   }
   void test_visitVariableDeclarationList_const_type() {
-    assertSource("const C a, b", ASTFactory.variableDeclarationList(Keyword.CONST, ASTFactory.typeName4("C", []), [ASTFactory.variableDeclaration("a"), ASTFactory.variableDeclaration("b")]));
+    assertSource("const C a, b", ASTFactory.variableDeclarationList(Keyword.CONST, ASTFactory.typeName4("C", []), [
+        ASTFactory.variableDeclaration("a"),
+        ASTFactory.variableDeclaration("b")]));
   }
   void test_visitVariableDeclarationList_final_noType() {
-    assertSource("final a, b", ASTFactory.variableDeclarationList2(Keyword.FINAL, [ASTFactory.variableDeclaration("a"), ASTFactory.variableDeclaration("b")]));
+    assertSource("final a, b", ASTFactory.variableDeclarationList2(Keyword.FINAL, [
+        ASTFactory.variableDeclaration("a"),
+        ASTFactory.variableDeclaration("b")]));
   }
   void test_visitVariableDeclarationList_type() {
-    assertSource("C a, b", ASTFactory.variableDeclarationList(null, ASTFactory.typeName4("C", []), [ASTFactory.variableDeclaration("a"), ASTFactory.variableDeclaration("b")]));
+    assertSource("C a, b", ASTFactory.variableDeclarationList(null, ASTFactory.typeName4("C", []), [
+        ASTFactory.variableDeclaration("a"),
+        ASTFactory.variableDeclaration("b")]));
   }
   void test_visitVariableDeclarationList_var() {
-    assertSource("var a, b", ASTFactory.variableDeclarationList2(Keyword.VAR, [ASTFactory.variableDeclaration("a"), ASTFactory.variableDeclaration("b")]));
+    assertSource("var a, b", ASTFactory.variableDeclarationList2(Keyword.VAR, [
+        ASTFactory.variableDeclaration("a"),
+        ASTFactory.variableDeclaration("b")]));
   }
   void test_visitVariableDeclarationStatement() {
     assertSource("C c;", ASTFactory.variableDeclarationStatement(null, ASTFactory.typeName4("C", []), [ASTFactory.variableDeclaration("c")]));
   }
   void test_visitWhileStatement() {
     assertSource("while (c) {}", ASTFactory.whileStatement(ASTFactory.identifier3("c"), ASTFactory.block([])));
   }
   void test_visitWithClause_multiple() {
-    assertSource("with A, B, C", ASTFactory.withClause([ASTFactory.typeName4("A", []), ASTFactory.typeName4("B", []), ASTFactory.typeName4("C", [])]));
+    assertSource("with A, B, C", ASTFactory.withClause([
+        ASTFactory.typeName4("A", []),
+        ASTFactory.typeName4("B", []),
+        ASTFactory.typeName4("C", [])]));
   }
   void test_visitWithClause_single() {
     assertSource("with A", ASTFactory.withClause([ASTFactory.typeName4("A", [])]));
   }
 
   /**
    * Assert that a `ToSourceVisitor` will produce the expected source when visiting the given
    * node.
    *
    * @param expectedSource the source string that the visitor is expected to produce
@@ skipping 992 matching lines @@
 }
 main() {
   ConstantEvaluatorTest.dartSuite();
   NodeLocatorTest.dartSuite();
   ToSourceVisitorTest.dartSuite();
   BreadthFirstVisitorTest.dartSuite();
   IndexExpressionTest.dartSuite();
   SimpleIdentifierTest.dartSuite();
   VariableDeclarationTest.dartSuite();
 }