Format and sort analyzer and analysis_server packages.

pkg/analyzer/test/generated/ast_test.dart

Index: pkg/analyzer/test/generated/ast_test.dart
diff --git a/pkg/analyzer/test/generated/ast_test.dart b/pkg/analyzer/test/generated/ast_test.dart
index 7a4e34cf3f5028d3e2ac4c91ed39442caf5c161d..7ab90f22e2794135831e4376206895f826e39fb8 100644
--- a/pkg/analyzer/test/generated/ast_test.dart
+++ b/pkg/analyzer/test/generated/ast_test.dart
@@ -7,38 +7,63 @@
 
 library engine.ast_test;
 
+import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/java_core.dart';
-import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart' show Predicate;
+import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/scanner.dart';
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:unittest/unittest.dart';
-import 'parser_test.dart' show ParserTestCase;
-import 'test_support.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
+import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
+import 'parser_test.dart' show ParserTestCase;
+import 'test_support.dart';
 
 
+main() {
+  groupSep = ' | ';
+  runReflectiveTests(BreadthFirstVisitorTest);
+  runReflectiveTests(ClassDeclarationTest);
+  runReflectiveTests(ClassTypeAliasTest);
+  runReflectiveTests(ConstantEvaluatorTest);
+  runReflectiveTests(ConstructorDeclarationTest);
+  runReflectiveTests(IndexExpressionTest);
+  runReflectiveTests(NodeListTest);
+  runReflectiveTests(NodeLocatorTest);
+  runReflectiveTests(SimpleIdentifierTest);
+  runReflectiveTests(SimpleStringLiteralTest);
+  runReflectiveTests(StringInterpolationTest);
+  runReflectiveTests(ToSourceVisitorTest);
+  runReflectiveTests(VariableDeclarationTest);
+}
+
 class AssignmentKind extends Enum<AssignmentKind> {
   static const AssignmentKind BINARY = const AssignmentKind('BINARY', 0);
 
-  static const AssignmentKind COMPOUND_LEFT = const AssignmentKind('COMPOUND_LEFT', 1);
+  static const AssignmentKind COMPOUND_LEFT =
+      const AssignmentKind('COMPOUND_LEFT', 1);
 
-  static const AssignmentKind COMPOUND_RIGHT = const AssignmentKind('COMPOUND_RIGHT', 2);
+  static const AssignmentKind COMPOUND_RIGHT =
+      const AssignmentKind('COMPOUND_RIGHT', 2);
 
-  static const AssignmentKind POSTFIX_INC = const AssignmentKind('POSTFIX_INC', 3);
+  static const AssignmentKind POSTFIX_INC =
+      const AssignmentKind('POSTFIX_INC', 3);
 
-  static const AssignmentKind PREFIX_DEC = const AssignmentKind('PREFIX_DEC', 4);
+  static const AssignmentKind PREFIX_DEC =
+      const AssignmentKind('PREFIX_DEC', 4);
 
-  static const AssignmentKind PREFIX_INC = const AssignmentKind('PREFIX_INC', 5);
+  static const AssignmentKind PREFIX_INC =
+      const AssignmentKind('PREFIX_INC', 5);
 
-  static const AssignmentKind PREFIX_NOT = const AssignmentKind('PREFIX_NOT', 6);
+  static const AssignmentKind PREFIX_NOT =
+      const AssignmentKind('PREFIX_NOT', 6);
 
-  static const AssignmentKind SIMPLE_LEFT = const AssignmentKind('SIMPLE_LEFT', 7);
+  static const AssignmentKind SIMPLE_LEFT =
+      const AssignmentKind('SIMPLE_LEFT', 7);
 
-  static const AssignmentKind SIMPLE_RIGHT = const AssignmentKind('SIMPLE_RIGHT', 8);
+  static const AssignmentKind SIMPLE_RIGHT =
+      const AssignmentKind('SIMPLE_RIGHT', 8);
 
   static const AssignmentKind NONE = const AssignmentKind('NONE', 9);
 
@@ -57,6 +82,19 @@ class AssignmentKind extends Enum<AssignmentKind> {
   const AssignmentKind(String name, int ordinal) : super(name, ordinal);
 }
 
+class BreadthFirstVisitor_BreadthFirstVisitorTest_testIt extends
+    BreadthFirstVisitor<Object> {
+  List<AstNode> nodes;
+
+  BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(this.nodes) : super();
+
+  @override
+  Object visitNode(AstNode node) {
+    nodes.add(node);
+    return super.visitNode(node);
+  }
+}
+
 class BreadthFirstVisitorTest extends ParserTestCase {
   void test_it() {
     String source = r'''
@@ -80,37 +118,62 @@ A f(var p) {
 }''';
     CompilationUnit unit = ParserTestCase.parseCompilationUnit(source);
     List<AstNode> nodes = new List<AstNode>();
-    BreadthFirstVisitor<Object> visitor = new BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(nodes);
+    BreadthFirstVisitor<Object> visitor =
+        new BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(nodes);
     visitor.visitAllNodes(unit);
     expect(nodes, hasLength(59));
-    EngineTestCase.assertInstanceOf((obj) => obj is CompilationUnit, CompilationUnit, nodes[0]);
-    EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, nodes[2]);
-    EngineTestCase.assertInstanceOf((obj) => obj is FunctionDeclaration, FunctionDeclaration, nodes[3]);
-    EngineTestCase.assertInstanceOf((obj) => obj is FunctionDeclarationStatement, FunctionDeclarationStatement, nodes[27]);
-    EngineTestCase.assertInstanceOf((obj) => obj is IntegerLiteral, IntegerLiteral, nodes[58]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is CompilationUnit,
+        CompilationUnit,
+        nodes[0]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is ClassDeclaration,
+        ClassDeclaration,
+        nodes[2]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is FunctionDeclaration,
+        FunctionDeclaration,
+        nodes[3]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is FunctionDeclarationStatement,
+        FunctionDeclarationStatement,
+        nodes[27]);
+    EngineTestCase.assertInstanceOf(
+        (obj) => obj is IntegerLiteral,
+        IntegerLiteral,
+        nodes[58]);
     //3
   }
 }
 
-class BreadthFirstVisitor_BreadthFirstVisitorTest_testIt extends BreadthFirstVisitor<Object> {
-  List<AstNode> nodes;
-
-  BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(this.nodes) : super();
-
-  @override
-  Object visitNode(AstNode node) {
-    nodes.add(node);
-    return super.visitNode(node);
-  }
-}
-
 class ClassDeclarationTest extends ParserTestCase {
   void test_getConstructor() {
-    List<ConstructorInitializer> initializers = new List<ConstructorInitializer>();
-    ConstructorDeclaration defaultConstructor = AstFactory.constructorDeclaration(AstFactory.identifier3("Test"), null, AstFactory.formalParameterList(), initializers);
-    ConstructorDeclaration aConstructor = AstFactory.constructorDeclaration(AstFactory.identifier3("Test"), "a", AstFactory.formalParameterList(), initializers);
-    ConstructorDeclaration bConstructor = AstFactory.constructorDeclaration(AstFactory.identifier3("Test"), "b", AstFactory.formalParameterList(), initializers);
-    ClassDeclaration clazz = AstFactory.classDeclaration(null, "Test", null, null, null, null, [defaultConstructor, aConstructor, bConstructor]);
+    List<ConstructorInitializer> initializers =
+        new List<ConstructorInitializer>();
+    ConstructorDeclaration defaultConstructor =
+        AstFactory.constructorDeclaration(
+            AstFactory.identifier3("Test"),
+            null,
+            AstFactory.formalParameterList(),
+            initializers);
+    ConstructorDeclaration aConstructor = AstFactory.constructorDeclaration(
+        AstFactory.identifier3("Test"),
+        "a",
+        AstFactory.formalParameterList(),
+        initializers);
+    ConstructorDeclaration bConstructor = AstFactory.constructorDeclaration(
+        AstFactory.identifier3("Test"),
+        "b",
+        AstFactory.formalParameterList(),
+        initializers);
+    ClassDeclaration clazz = AstFactory.classDeclaration(
+        null,
+        "Test",
+        null,
+        null,
+        null,
+        null,
+        [defaultConstructor, aConstructor, bConstructor]);
     expect(clazz.getConstructor(null), same(defaultConstructor));
     expect(clazz.getConstructor("a"), same(aConstructor));
     expect(clazz.getConstructor("b"), same(bConstructor));
@@ -121,9 +184,16 @@ class ClassDeclarationTest extends ParserTestCase {
     VariableDeclaration aVar = AstFactory.variableDeclaration("a");
     VariableDeclaration bVar = AstFactory.variableDeclaration("b");
     VariableDeclaration cVar = AstFactory.variableDeclaration("c");
-    ClassDeclaration clazz = AstFactory.classDeclaration(null, "Test", null, null, null, null, [
-        AstFactory.fieldDeclaration2(false, null, [aVar]),
-        AstFactory.fieldDeclaration2(false, null, [bVar, cVar])]);
+    ClassDeclaration clazz = AstFactory.classDeclaration(
+        null,
+        "Test",
+        null,
+        null,
+        null,
+        null,
+        [
+            AstFactory.fieldDeclaration2(false, null, [aVar]),
+            AstFactory.fieldDeclaration2(false, null, [bVar, cVar])]);
     expect(clazz.getField("a"), same(aVar));
     expect(clazz.getField("b"), same(bVar));
     expect(clazz.getField("c"), same(cVar));
@@ -131,24 +201,63 @@ class ClassDeclarationTest extends ParserTestCase {
   }
 
   void test_getMethod() {
-    MethodDeclaration aMethod = AstFactory.methodDeclaration(null, null, null, null, AstFactory.identifier3("a"), AstFactory.formalParameterList());
-    MethodDeclaration bMethod = AstFactory.methodDeclaration(null, null, null, null, AstFactory.identifier3("b"), AstFactory.formalParameterList());
-    ClassDeclaration clazz = AstFactory.classDeclaration(null, "Test", null, null, null, null, [aMethod, bMethod]);
+    MethodDeclaration aMethod = AstFactory.methodDeclaration(
+        null,
+        null,
+        null,
+        null,
+        AstFactory.identifier3("a"),
+        AstFactory.formalParameterList());
+    MethodDeclaration bMethod = AstFactory.methodDeclaration(
+        null,
+        null,
+        null,
+        null,
+        AstFactory.identifier3("b"),
+        AstFactory.formalParameterList());
+    ClassDeclaration clazz = AstFactory.classDeclaration(
+        null,
+        "Test",
+        null,
+        null,
+        null,
+        null,
+        [aMethod, bMethod]);
     expect(clazz.getMethod("a"), same(aMethod));
     expect(clazz.getMethod("b"), same(bMethod));
     expect(clazz.getMethod("noSuchMethod"), same(null));
   }
 
   void test_isAbstract() {
-    expect(AstFactory.classDeclaration(null, "A", null, null, null, null).isAbstract, isFalse);
-    expect(AstFactory.classDeclaration(Keyword.ABSTRACT, "B", null, null, null, null).isAbstract, isTrue);
+    expect(
+        AstFactory.classDeclaration(null, "A", null, null, null, null).isAbstract,
+        isFalse);
+    expect(
+        AstFactory.classDeclaration(
+            Keyword.ABSTRACT,
+            "B",
+            null,
+            null,
+            null,
+            null).isAbstract,
+        isTrue);
   }
 }
 
 class ClassTypeAliasTest extends ParserTestCase {
   void test_isAbstract() {
-    expect(AstFactory.classTypeAlias("A", null, null, null, null, null).isAbstract, isFalse);
-    expect(AstFactory.classTypeAlias("B", null, Keyword.ABSTRACT, null, null, null).isAbstract, isTrue);
+    expect(
+        AstFactory.classTypeAlias("A", null, null, null, null, null).isAbstract,
+        isFalse);
+    expect(
+        AstFactory.classTypeAlias(
+            "B",
+            null,
+            Keyword.ABSTRACT,
+            null,
+            null,
+            null).isAbstract,
+        isTrue);
   }
 }
 
@@ -465,164 +574,217 @@ class ConstantEvaluatorTest extends ParserTestCase {
     expect(value as int, -42);
   }
 
-  Object _getConstantValue(String source) => ParserTestCase.parseExpression(source).accept(new ConstantEvaluator());
+  Object _getConstantValue(String source) =>
+      ParserTestCase.parseExpression(source).accept(new ConstantEvaluator());
 }
 
 class ConstructorDeclarationTest extends EngineTestCase {
-  void test_firstTokenAfterCommentAndMetadata_externalOnly() {
+  void test_firstTokenAfterCommentAndMetadata_all_inverted() {
     Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
+    externalKeyword.offset = 14;
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
-        null,
-        null,
+        Keyword.CONST,
+        Keyword.FACTORY,
         AstFactory.identifier3('int'),
         null,
         null,
         null,
         null);
     declaration.externalKeyword = externalKeyword;
-    expect(declaration.firstTokenAfterCommentAndMetadata, externalKeyword);
+    declaration.constKeyword.offset = 8;
+    Token factoryKeyword = declaration.factoryKeyword;
+    factoryKeyword.offset = 0;
+    expect(declaration.firstTokenAfterCommentAndMetadata, factoryKeyword);
   }
 
-  void test_firstTokenAfterCommentAndMetadata_constOnly() {
+  void test_firstTokenAfterCommentAndMetadata_all_normal() {
+    Token token = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
+    token.offset = 0;
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
         Keyword.CONST,
-        null,
+        Keyword.FACTORY,
         AstFactory.identifier3('int'),
         null,
         null,
         null,
         null);
-    expect(declaration.firstTokenAfterCommentAndMetadata, declaration.constKeyword);
+    declaration.externalKeyword = token;
+    declaration.constKeyword.offset = 9;
+    declaration.factoryKeyword.offset = 15;
+    expect(declaration.firstTokenAfterCommentAndMetadata, token);
   }
 
-  void test_firstTokenAfterCommentAndMetadata_factoryOnly() {
+  void test_firstTokenAfterCommentAndMetadata_constOnly() {
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
+        Keyword.CONST,
         null,
-        Keyword.FACTORY,
         AstFactory.identifier3('int'),
         null,
         null,
         null,
         null);
-    expect(declaration.firstTokenAfterCommentAndMetadata, declaration.factoryKeyword);
+    expect(
+        declaration.firstTokenAfterCommentAndMetadata,
+        declaration.constKeyword);
   }
 
-  void test_firstTokenAfterCommentAndMetadata_all_inverted() {
+  void test_firstTokenAfterCommentAndMetadata_externalOnly() {
     Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
-    externalKeyword.offset = 14;
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
-        Keyword.CONST,
-        Keyword.FACTORY,
+        null,
+        null,
         AstFactory.identifier3('int'),
         null,
         null,
         null,
         null);
     declaration.externalKeyword = externalKeyword;
-    declaration.constKeyword.offset = 8;
-    Token factoryKeyword = declaration.factoryKeyword;
-    factoryKeyword.offset = 0;
-    expect(declaration.firstTokenAfterCommentAndMetadata, factoryKeyword);
+    expect(declaration.firstTokenAfterCommentAndMetadata, externalKeyword);
   }
 
-  void test_firstTokenAfterCommentAndMetadata_all_normal() {
-    Token token = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
-    token.offset = 0;
+  void test_firstTokenAfterCommentAndMetadata_factoryOnly() {
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
-        Keyword.CONST,
+        null,
         Keyword.FACTORY,
         AstFactory.identifier3('int'),
         null,
         null,
         null,
         null);
-    declaration.externalKeyword = token;
-    declaration.constKeyword.offset = 9;
-    declaration.factoryKeyword.offset = 15;
-    expect(declaration.firstTokenAfterCommentAndMetadata, token);
+    expect(
+        declaration.firstTokenAfterCommentAndMetadata,
+        declaration.factoryKeyword);
   }
 }
 
 class IndexExpressionTest extends EngineTestCase {
   void test_inGetterContext_assignment_compound_left() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // a[b] += c
-    AstFactory.assignmentExpression(expression, TokenType.PLUS_EQ, AstFactory.identifier3("c"));
+    AstFactory.assignmentExpression(
+        expression,
+        TokenType.PLUS_EQ,
+        AstFactory.identifier3("c"));
     expect(expression.inGetterContext(), isTrue);
   }
 
   void test_inGetterContext_assignment_simple_left() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // a[b] = c
-    AstFactory.assignmentExpression(expression, TokenType.EQ, AstFactory.identifier3("c"));
+    AstFactory.assignmentExpression(
+        expression,
+        TokenType.EQ,
+        AstFactory.identifier3("c"));
     expect(expression.inGetterContext(), isFalse);
   }
 
   void test_inGetterContext_nonAssignment() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // a[b] + c
-    AstFactory.binaryExpression(expression, TokenType.PLUS, AstFactory.identifier3("c"));
+    AstFactory.binaryExpression(
+        expression,
+        TokenType.PLUS,
+        AstFactory.identifier3("c"));
     expect(expression.inGetterContext(), isTrue);
   }
 
   void test_inSetterContext_assignment_compound_left() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // a[b] += c
-    AstFactory.assignmentExpression(expression, TokenType.PLUS_EQ, AstFactory.identifier3("c"));
+    AstFactory.assignmentExpression(
+        expression,
+        TokenType.PLUS_EQ,
+        AstFactory.identifier3("c"));
     expect(expression.inSetterContext(), isTrue);
   }
 
   void test_inSetterContext_assignment_compound_right() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // c += a[b]
-    AstFactory.assignmentExpression(AstFactory.identifier3("c"), TokenType.PLUS_EQ, expression);
+    AstFactory.assignmentExpression(
+        AstFactory.identifier3("c"),
+        TokenType.PLUS_EQ,
+        expression);
     expect(expression.inSetterContext(), isFalse);
   }
 
   void test_inSetterContext_assignment_simple_left() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // a[b] = c
-    AstFactory.assignmentExpression(expression, TokenType.EQ, AstFactory.identifier3("c"));
+    AstFactory.assignmentExpression(
+        expression,
+        TokenType.EQ,
+        AstFactory.identifier3("c"));
     expect(expression.inSetterContext(), isTrue);
   }
 
   void test_inSetterContext_assignment_simple_right() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // c = a[b]
-    AstFactory.assignmentExpression(AstFactory.identifier3("c"), TokenType.EQ, expression);
+    AstFactory.assignmentExpression(
+        AstFactory.identifier3("c"),
+        TokenType.EQ,
+        expression);
     expect(expression.inSetterContext(), isFalse);
   }
 
   void test_inSetterContext_nonAssignment() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
-    AstFactory.binaryExpression(expression, TokenType.PLUS, AstFactory.identifier3("c"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
+    AstFactory.binaryExpression(
+        expression,
+        TokenType.PLUS,
+        AstFactory.identifier3("c"));
     // a[b] + cc
     expect(expression.inSetterContext(), isFalse);
   }
 
   void test_inSetterContext_postfix() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     AstFactory.postfixExpression(expression, TokenType.PLUS_PLUS);
     // a[b]++
     expect(expression.inSetterContext(), isTrue);
   }
 
   void test_inSetterContext_prefix_bang() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // !a[b]
     AstFactory.prefixExpression(TokenType.BANG, expression);
     expect(expression.inSetterContext(), isFalse);
   }
 
   void test_inSetterContext_prefix_minusMinus() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // --a[b]
     AstFactory.prefixExpression(TokenType.MINUS_MINUS, expression);
     expect(expression.inSetterContext(), isTrue);
   }
 
   void test_inSetterContext_prefix_plusPlus() {
-    IndexExpression expression = AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"));
+    IndexExpression expression = AstFactory.indexExpression(
+        AstFactory.identifier3("a"),
+        AstFactory.identifier3("b"));
     // ++a[b]
     AstFactory.prefixExpression(TokenType.PLUS_PLUS, expression);
     expect(expression.inSetterContext(), isTrue);
@@ -739,7 +901,8 @@ class NodeListTest extends EngineTestCase {
 
   void test_getBeginToken_nonEmpty() {
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
-    AstNode node = AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
+    AstNode node =
+        AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
     list.add(node);
     expect(list.beginToken, same(node.beginToken));
   }
@@ -751,7 +914,8 @@ class NodeListTest extends EngineTestCase {
 
   void test_getEndToken_nonEmpty() {
     NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
-    AstNode node = AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
+    AstNode node =
+        AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
     list.add(node);
     expect(list.endToken, same(node.endToken));
   }
@@ -856,8 +1020,14 @@ class NodeListTest extends EngineTestCase {
 
 class NodeLocatorTest extends ParserTestCase {
   void test_range() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit("library myLib;");
-    _assertLocate(unit, 4, 10, (node) => node is LibraryDirective, LibraryDirective);
+    CompilationUnit unit =
+        ParserTestCase.parseCompilationUnit("library myLib;");
+    _assertLocate(
+        unit,
+        4,
+        10,
+        (node) => node is LibraryDirective,
+        LibraryDirective);
   }
 
   void test_searchWithin_null() {
@@ -866,8 +1036,14 @@ class NodeLocatorTest extends ParserTestCase {
   }
 
   void test_searchWithin_offset() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit("library myLib;");
-    _assertLocate(unit, 10, 10, (node) => node is SimpleIdentifier, SimpleIdentifier);
+    CompilationUnit unit =
+        ParserTestCase.parseCompilationUnit("library myLib;");
+    _assertLocate(
+        unit,
+        10,
+        10,
+        (node) => node is SimpleIdentifier,
+        SimpleIdentifier);
   }
 
   void test_searchWithin_offsetAfterNode() {
@@ -888,40 +1064,52 @@ class B {}''');
     expect(node, isNull);
   }
 
-  void _assertLocate(CompilationUnit unit, int start, int end, Predicate<AstNode> predicate, Type expectedClass) {
+  void _assertLocate(CompilationUnit unit, int start, int end,
+      Predicate<AstNode> predicate, Type expectedClass) {
     NodeLocator locator = new NodeLocator.con2(start, end);
     AstNode node = locator.searchWithin(unit);
     expect(node, isNotNull);
     expect(locator.foundNode, same(node));
     expect(node.offset <= start, isTrue, reason: "Node starts after range");
-    expect(node.offset + node.length > end, isTrue, reason: "Node ends before range");
+    expect(
+        node.offset + node.length > end,
+        isTrue,
+        reason: "Node ends before range");
     EngineTestCase.assertInstanceOf(predicate, expectedClass, node);
   }
 }
 
 class SimpleIdentifierTest extends ParserTestCase {
   void test_inDeclarationContext_catch_exception() {
-    SimpleIdentifier identifier = AstFactory.catchClause("e").exceptionParameter;
+    SimpleIdentifier identifier =
+        AstFactory.catchClause("e").exceptionParameter;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_catch_stack() {
-    SimpleIdentifier identifier = AstFactory.catchClause2("e", "s").stackTraceParameter;
+    SimpleIdentifier identifier =
+        AstFactory.catchClause2("e", "s").stackTraceParameter;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_classDeclaration() {
-    SimpleIdentifier identifier = AstFactory.classDeclaration(null, "C", null, null, null, null).name;
+    SimpleIdentifier identifier =
+        AstFactory.classDeclaration(null, "C", null, null, null, null).name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_classTypeAlias() {
-    SimpleIdentifier identifier = AstFactory.classTypeAlias("C", null, null, null, null, null).name;
+    SimpleIdentifier identifier =
+        AstFactory.classTypeAlias("C", null, null, null, null, null).name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_constructorDeclaration() {
-    SimpleIdentifier identifier = AstFactory.constructorDeclaration(AstFactory.identifier3("C"), "c", null, null).name;
+    SimpleIdentifier identifier = AstFactory.constructorDeclaration(
+        AstFactory.identifier3("C"),
+        "c",
+        null,
+        null).name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
@@ -932,34 +1120,40 @@ class SimpleIdentifierTest extends ParserTestCase {
   }
 
   void test_inDeclarationContext_enumConstantDeclaration() {
-    EnumDeclaration enumDeclaration = AstFactory.enumDeclaration2('MyEnum', ['CONST']);
+    EnumDeclaration enumDeclaration =
+        AstFactory.enumDeclaration2('MyEnum', ['CONST']);
     SimpleIdentifier identifier = enumDeclaration.constants[0].name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_enumDeclaration() {
-    EnumDeclaration enumDeclaration = AstFactory.enumDeclaration2('MyEnum', ['A', 'B', 'C']);
+    EnumDeclaration enumDeclaration =
+        AstFactory.enumDeclaration2('MyEnum', ['A', 'B', 'C']);
     SimpleIdentifier identifier = enumDeclaration.name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_fieldFormalParameter() {
-    SimpleIdentifier identifier = AstFactory.fieldFormalParameter2("p").identifier;
+    SimpleIdentifier identifier =
+        AstFactory.fieldFormalParameter2("p").identifier;
     expect(identifier.inDeclarationContext(), isFalse);
   }
 
   void test_inDeclarationContext_functionDeclaration() {
-    SimpleIdentifier identifier = AstFactory.functionDeclaration(null, null, "f", null).name;
+    SimpleIdentifier identifier =
+        AstFactory.functionDeclaration(null, null, "f", null).name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_functionTypeAlias() {
-    SimpleIdentifier identifier = AstFactory.typeAlias(null, "F", null, null).name;
+    SimpleIdentifier identifier =
+        AstFactory.typeAlias(null, "F", null, null).name;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_label_false() {
-    SimpleIdentifier identifier = AstFactory.namedExpression2("l", AstFactory.integer(0)).name.label;
+    SimpleIdentifier identifier =
+        AstFactory.namedExpression2("l", AstFactory.integer(0)).name.label;
     expect(identifier.inDeclarationContext(), isFalse);
   }
 
@@ -972,17 +1166,26 @@ class SimpleIdentifierTest extends ParserTestCase {
 
   void test_inDeclarationContext_methodDeclaration() {
     SimpleIdentifier identifier = AstFactory.identifier3("m");
-    AstFactory.methodDeclaration2(null, null, null, null, identifier, null, null);
+    AstFactory.methodDeclaration2(
+        null,
+        null,
+        null,
+        null,
+        identifier,
+        null,
+        null);
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_prefix() {
-    SimpleIdentifier identifier = AstFactory.importDirective3("uri", "pref").prefix;
+    SimpleIdentifier identifier =
+        AstFactory.importDirective3("uri", "pref").prefix;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
   void test_inDeclarationContext_simpleFormalParameter() {
-    SimpleIdentifier identifier = AstFactory.simpleFormalParameter3("p").identifier;
+    SimpleIdentifier identifier =
+        AstFactory.simpleFormalParameter3("p").identifier;
     expect(identifier.inDeclarationContext(), isTrue);
   }
 
@@ -1007,7 +1210,9 @@ class SimpleIdentifierTest extends ParserTestCase {
     for (WrapperKind wrapper in WrapperKind.values) {
       for (AssignmentKind assignment in AssignmentKind.values) {
         SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
-        if (assignment == AssignmentKind.SIMPLE_LEFT && wrapper != WrapperKind.PREFIXED_LEFT && wrapper != WrapperKind.PROPERTY_LEFT) {
+        if (assignment == AssignmentKind.SIMPLE_LEFT &&
+            wrapper != WrapperKind.PREFIXED_LEFT &&
+            wrapper != WrapperKind.PROPERTY_LEFT) {
           if (identifier.inGetterContext()) {
             fail("Expected ${_topMostNode(identifier).toSource()} to be false");
           }
@@ -1030,7 +1235,9 @@ class SimpleIdentifierTest extends ParserTestCase {
 
   void test_inReferenceContext() {
     SimpleIdentifier identifier = AstFactory.identifier3("id");
-    AstFactory.namedExpression(AstFactory.label(identifier), AstFactory.identifier3("_"));
+    AstFactory.namedExpression(
+        AstFactory.label(identifier),
+        AstFactory.identifier3("_"));
     expect(identifier.inGetterContext(), isFalse);
     expect(identifier.inSetterContext(), isFalse);
   }
@@ -1039,7 +1246,13 @@ class SimpleIdentifierTest extends ParserTestCase {
     for (WrapperKind wrapper in WrapperKind.values) {
       for (AssignmentKind assignment in AssignmentKind.values) {
         SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
-        if (wrapper == WrapperKind.PREFIXED_LEFT || wrapper == WrapperKind.PROPERTY_LEFT || assignment == AssignmentKind.BINARY || assignment == AssignmentKind.COMPOUND_RIGHT || assignment == AssignmentKind.PREFIX_NOT || assignment == AssignmentKind.SIMPLE_RIGHT || assignment == AssignmentKind.NONE) {
+        if (wrapper == WrapperKind.PREFIXED_LEFT ||
+            wrapper == WrapperKind.PROPERTY_LEFT ||
+            assignment == AssignmentKind.BINARY ||
+            assignment == AssignmentKind.COMPOUND_RIGHT ||
+            assignment == AssignmentKind.PREFIX_NOT ||
+            assignment == AssignmentKind.SIMPLE_RIGHT ||
+            assignment == AssignmentKind.NONE) {
           if (identifier.inSetterContext()) {
             fail("Expected ${_topMostNode(identifier).toSource()} to be false");
           }
@@ -1061,13 +1274,17 @@ class SimpleIdentifierTest extends ParserTestCase {
   }
 
   void test_isQualified_inMethodInvocation_noTarget() {
-    MethodInvocation invocation = AstFactory.methodInvocation2("test", [AstFactory.identifier3("arg0")]);
+    MethodInvocation invocation =
+        AstFactory.methodInvocation2("test", [AstFactory.identifier3("arg0")]);
     SimpleIdentifier identifier = invocation.methodName;
     expect(identifier.isQualified, isFalse);
   }
 
   void test_isQualified_inMethodInvocation_withTarget() {
-    MethodInvocation invocation = AstFactory.methodInvocation(AstFactory.identifier3("target"), "test", [AstFactory.identifier3("arg0")]);
+    MethodInvocation invocation = AstFactory.methodInvocation(
+        AstFactory.identifier3("target"),
+        "test",
+        [AstFactory.identifier3("arg0")]);
     SimpleIdentifier identifier = invocation.methodName;
     expect(identifier.isQualified, isTrue);
   }
@@ -1102,29 +1319,42 @@ class SimpleIdentifierTest extends ParserTestCase {
     expect(identifier.isQualified, isFalse);
   }
 
-  SimpleIdentifier _createIdentifier(WrapperKind wrapper, AssignmentKind assignment) {
+  SimpleIdentifier _createIdentifier(WrapperKind wrapper,
+      AssignmentKind assignment) {
     SimpleIdentifier identifier = AstFactory.identifier3("a");
     Expression expression = identifier;
     while (true) {
       if (wrapper == WrapperKind.PREFIXED_LEFT) {
-        expression = AstFactory.identifier(identifier, AstFactory.identifier3("_"));
+        expression =
+            AstFactory.identifier(identifier, AstFactory.identifier3("_"));
       } else if (wrapper == WrapperKind.PREFIXED_RIGHT) {
-        expression = AstFactory.identifier(AstFactory.identifier3("_"), identifier);
+        expression =
+            AstFactory.identifier(AstFactory.identifier3("_"), identifier);
       } else if (wrapper == WrapperKind.PROPERTY_LEFT) {
         expression = AstFactory.propertyAccess2(expression, "_");
       } else if (wrapper == WrapperKind.PROPERTY_RIGHT) {
-        expression = AstFactory.propertyAccess(AstFactory.identifier3("_"), identifier);
+        expression =
+            AstFactory.propertyAccess(AstFactory.identifier3("_"), identifier);
       } else if (wrapper == WrapperKind.NONE) {
       }
       break;
     }
     while (true) {
       if (assignment == AssignmentKind.BINARY) {
-        AstFactory.binaryExpression(expression, TokenType.PLUS, AstFactory.identifier3("_"));
+        AstFactory.binaryExpression(
+            expression,
+            TokenType.PLUS,
+            AstFactory.identifier3("_"));
       } else if (assignment == AssignmentKind.COMPOUND_LEFT) {
-        AstFactory.assignmentExpression(expression, TokenType.PLUS_EQ, AstFactory.identifier3("_"));
+        AstFactory.assignmentExpression(
+            expression,
+            TokenType.PLUS_EQ,
+            AstFactory.identifier3("_"));
       } else if (assignment == AssignmentKind.COMPOUND_RIGHT) {
-        AstFactory.assignmentExpression(AstFactory.identifier3("_"), TokenType.PLUS_EQ, expression);
+        AstFactory.assignmentExpression(
+            AstFactory.identifier3("_"),
+            TokenType.PLUS_EQ,
+            expression);
       } else if (assignment == AssignmentKind.POSTFIX_INC) {
         AstFactory.postfixExpression(expression, TokenType.PLUS_PLUS);
       } else if (assignment == AssignmentKind.PREFIX_DEC) {
@@ -1134,9 +1364,15 @@ class SimpleIdentifierTest extends ParserTestCase {
       } else if (assignment == AssignmentKind.PREFIX_NOT) {
         AstFactory.prefixExpression(TokenType.BANG, expression);
       } else if (assignment == AssignmentKind.SIMPLE_LEFT) {
-        AstFactory.assignmentExpression(expression, TokenType.EQ, AstFactory.identifier3("_"));
+        AstFactory.assignmentExpression(
+            expression,
+            TokenType.EQ,
+            AstFactory.identifier3("_"));
       } else if (assignment == AssignmentKind.SIMPLE_RIGHT) {
-        AstFactory.assignmentExpression(AstFactory.identifier3("_"), TokenType.EQ, expression);
+        AstFactory.assignmentExpression(
+            AstFactory.identifier3("_"),
+            TokenType.EQ,
+            expression);
       } else if (assignment == AssignmentKind.NONE) {
       }
       break;
@@ -1162,26 +1398,152 @@ class SimpleIdentifierTest extends ParserTestCase {
 }
 
 class SimpleStringLiteralTest extends ParserTestCase {
+  void test_contentsEnd() {
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").contentsEnd,
+        2);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").contentsEnd,
+        2);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("\"\"\"X\"\"\""),
+            "X").contentsEnd,
+        4);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("'''X'''"),
+            "X").contentsEnd,
+        4);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").contentsEnd,
+        3);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"X\""),
+            "X").contentsEnd,
+        3);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
+            "X").contentsEnd,
+        5);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r'''X'''"),
+            "X").contentsEnd,
+        5);
+  }
+
   void test_contentsOffset() {
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").contentsOffset, 1);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").contentsOffset, 1);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X").contentsOffset, 3);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").contentsOffset, 3);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").contentsOffset, 2);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").contentsOffset, 2);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X").contentsOffset, 4);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").contentsOffset, 4);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("'X'"),
+            "X").contentsOffset,
+        1);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("\"X\""),
+            "X").contentsOffset,
+        1);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("\"\"\"X\"\"\""),
+            "X").contentsOffset,
+        3);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("'''X'''"),
+            "X").contentsOffset,
+        3);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r'X'"),
+            "X").contentsOffset,
+        2);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"X\""),
+            "X").contentsOffset,
+        2);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
+            "X").contentsOffset,
+        4);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r'''X'''"),
+            "X").contentsOffset,
+        4);
   }
 
-  void test_contentsEnd() {
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").contentsEnd, 2);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").contentsEnd, 2);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X").contentsEnd, 4);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").contentsEnd, 4);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").contentsEnd, 3);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").contentsEnd, 3);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X").contentsEnd, 5);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").contentsEnd, 5);
+  void test_isMultiline() {
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isMultiline,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isMultiline,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isMultiline,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"X\""),
+            "X").isMultiline,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("'''X'''"),
+            "X").isMultiline,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r'''X'''"),
+            "X").isMultiline,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("\"\"\"X\"\"\""),
+            "X").isMultiline,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
+            "X").isMultiline,
+        isTrue);
+  }
+
+  void test_isRaw() {
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isRaw,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isRaw,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("\"\"\"X\"\"\""),
+            "X").isRaw,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").isRaw,
+        isFalse);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isRaw,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").isRaw,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(
+            TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
+            "X").isRaw,
+        isTrue);
+    expect(
+        new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").isRaw,
+        isTrue);
   }
 
   void test_isSingleQuoted() {
@@ -1238,28 +1600,6 @@ class SimpleStringLiteralTest extends ParserTestCase {
     }
   }
 
-  void test_isMultiline() {
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isMultiline, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isMultiline, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isMultiline, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").isMultiline, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").isMultiline, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").isMultiline, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X").isMultiline, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X").isMultiline, isTrue);
-  }
-
-  void test_isRaw() {
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isRaw, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isRaw, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("\"\"\"X\"\"\""), "X").isRaw, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").isRaw, isFalse);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isRaw, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").isRaw, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r\"\"\"X\"\"\""), "X").isRaw, isTrue);
-    expect(new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").isRaw, isTrue);
-  }
-
   void test_simple() {
     Token token = TokenFactory.tokenFromString("'value'");
     SimpleStringLiteral stringLiteral = new SimpleStringLiteral(token, "value");
@@ -1361,6 +1701,11 @@ class StringInterpolationTest extends ParserTestCase {
     }
   }
 
+  void test_isRaw() {
+    StringInterpolation node = AstFactory.string();
+    expect(node.isRaw, isFalse);
+  }
+
   void test_isSingleQuoted() {
     var b = AstFactory.interpolationExpression(AstFactory.identifier3('bb'));
     // "
@@ -1392,16 +1737,13 @@ class StringInterpolationTest extends ParserTestCase {
       expect(node.isSingleQuoted, isTrue);
     }
   }
-
-  void test_isRaw() {
-    StringInterpolation node = AstFactory.string();
-    expect(node.isRaw, isFalse);
-  }
 }
 
 class ToSourceVisitorTest extends EngineTestCase {
   void test_visitAdjacentStrings() {
-    _assertSource("'a' 'b'", AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
+    _assertSource(
+        "'a' 'b'",
+        AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
   }
 
   void test_visitAnnotation_constant() {
@@ -1409,31 +1751,57 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitAnnotation_constructor() {
-    _assertSource("@A.c()", AstFactory.annotation2(AstFactory.identifier3("A"), AstFactory.identifier3("c"), AstFactory.argumentList()));
+    _assertSource(
+        "@A.c()",
+        AstFactory.annotation2(
+            AstFactory.identifier3("A"),
+            AstFactory.identifier3("c"),
+            AstFactory.argumentList()));
   }
 
   void test_visitArgumentList() {
-    _assertSource("(a, b)", AstFactory.argumentList([AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+    _assertSource(
+        "(a, b)",
+        AstFactory.argumentList(
+            [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitAsExpression() {
-    _assertSource("e as T", AstFactory.asExpression(AstFactory.identifier3("e"), AstFactory.typeName4("T")));
+    _assertSource(
+        "e as T",
+        AstFactory.asExpression(
+            AstFactory.identifier3("e"),
+            AstFactory.typeName4("T")));
   }
 
   void test_visitAssertStatement() {
-    _assertSource("assert (a);", AstFactory.assertStatement(AstFactory.identifier3("a")));
+    _assertSource(
+        "assert (a);",
+        AstFactory.assertStatement(AstFactory.identifier3("a")));
   }
 
   void test_visitAssignmentExpression() {
-    _assertSource("a = b", AstFactory.assignmentExpression(AstFactory.identifier3("a"), TokenType.EQ, AstFactory.identifier3("b")));
+    _assertSource(
+        "a = b",
+        AstFactory.assignmentExpression(
+            AstFactory.identifier3("a"),
+            TokenType.EQ,
+            AstFactory.identifier3("b")));
   }
 
   void test_visitAwaitExpression() {
-    _assertSource("await e;", AstFactory.awaitExpression(AstFactory.identifier3("e")));
+    _assertSource(
+        "await e;",
+        AstFactory.awaitExpression(AstFactory.identifier3("e")));
   }
 
   void test_visitBinaryExpression() {
-    _assertSource("a + b", AstFactory.binaryExpression(AstFactory.identifier3("a"), TokenType.PLUS, AstFactory.identifier3("b")));
+    _assertSource(
+        "a + b",
+        AstFactory.binaryExpression(
+            AstFactory.identifier3("a"),
+            TokenType.PLUS,
+            AstFactory.identifier3("b")));
   }
 
   void test_visitBlock_empty() {
@@ -1441,7 +1809,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitBlock_nonEmpty() {
-    _assertSource("{break; break;}", AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
+    _assertSource(
+        "{break; break;}",
+        AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
   }
 
   void test_visitBlockFunctionBody_async() {
@@ -1481,21 +1851,33 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   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() {
@@ -1507,123 +1889,322 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitCatchClause_on() {
-    _assertSource("on E {}", AstFactory.catchClause3(AstFactory.typeName4("E")));
+    _assertSource(
+        "on E {}",
+        AstFactory.catchClause3(AstFactory.typeName4("E")));
   }
 
   void test_visitCatchClause_on_catch() {
-    _assertSource("on E catch (e) {}", AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
+    _assertSource(
+        "on E catch (e) {}",
+        AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
   }
 
   void test_visitClassDeclaration_abstract() {
-    _assertSource("abstract class C {}", AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
+    _assertSource(
+        "abstract class C {}",
+        AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
   }
 
   void test_visitClassDeclaration_empty() {
-    _assertSource("class C {}", AstFactory.classDeclaration(null, "C", null, null, null, null));
+    _assertSource(
+        "class C {}",
+        AstFactory.classDeclaration(null, "C", null, null, null, null));
   }
 
   void test_visitClassDeclaration_extends() {
-    _assertSource("class C extends A {}", AstFactory.classDeclaration(null, "C", null, AstFactory.extendsClause(AstFactory.typeName4("A")), null, null));
+    _assertSource(
+        "class C extends A {}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            null,
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            null,
+            null));
   }
 
   void test_visitClassDeclaration_extends_implements() {
-    _assertSource("class C extends A implements B {}", AstFactory.classDeclaration(null, "C", null, AstFactory.extendsClause(AstFactory.typeName4("A")), null, AstFactory.implementsClause([AstFactory.typeName4("B")])));
+    _assertSource(
+        "class C extends A implements B {}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            null,
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            null,
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   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));
+    _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")])));
+    _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")])));
+    _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));
+    _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));
+    _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")])));
+    _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")])));
   }
 
   void test_visitClassDeclaration_parameters_extends_with() {
-    _assertSource("class C<E> extends A with M {}", AstFactory.classDeclaration(null, "C", AstFactory.typeParameterList(["E"]), AstFactory.extendsClause(AstFactory.typeName4("A")), AstFactory.withClause([AstFactory.typeName4("M")]), null));
+    _assertSource(
+        "class C<E> extends A with M {}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            null));
   }
 
   void test_visitClassDeclaration_parameters_extends_with_implements() {
-    _assertSource("class C<E> extends A with M implements B {}", AstFactory.classDeclaration(null, "C", AstFactory.typeParameterList(["E"]), AstFactory.extendsClause(AstFactory.typeName4("A")), AstFactory.withClause([AstFactory.typeName4("M")]), AstFactory.implementsClause([AstFactory.typeName4("B")])));
+    _assertSource(
+        "class C<E> extends A with M implements B {}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_parameters_implements() {
-    _assertSource("class C<E> implements B {}", AstFactory.classDeclaration(null, "C", AstFactory.typeParameterList(["E"]), null, null, AstFactory.implementsClause([AstFactory.typeName4("B")])));
+    _assertSource(
+        "class C<E> implements B {}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            null,
+            null,
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_singleMember() {
-    _assertSource("class C {var a;}", AstFactory.classDeclaration(null, "C", null, null, null, null, [AstFactory.fieldDeclaration2(false, Keyword.VAR, [AstFactory.variableDeclaration("a")])]));
+    _assertSource(
+        "class C {var a;}",
+        AstFactory.classDeclaration(
+            null,
+            "C",
+            null,
+            null,
+            null,
+            null,
+            [
+                AstFactory.fieldDeclaration2(
+                    false,
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitClassDeclaration_withMetadata() {
-    ClassDeclaration declaration = AstFactory.classDeclaration(null, "C", null, null, null, null);
-    declaration.metadata = [
-        AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    ClassDeclaration declaration =
+        AstFactory.classDeclaration(null, "C", null, null, null, null);
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated class C {}", declaration);
   }
 
   void test_visitClassTypeAlias_abstract() {
-    _assertSource("abstract class C = S with M1;", AstFactory.classTypeAlias("C", null, Keyword.ABSTRACT, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), null));
+    _assertSource(
+        "abstract class C = S with M1;",
+        AstFactory.classTypeAlias(
+            "C",
+            null,
+            Keyword.ABSTRACT,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            null));
   }
 
   void test_visitClassTypeAlias_abstract_implements() {
-    _assertSource("abstract class C = S with M1 implements I;", AstFactory.classTypeAlias("C", null, Keyword.ABSTRACT, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), AstFactory.implementsClause([AstFactory.typeName4("I")])));
+    _assertSource(
+        "abstract class C = S with M1 implements I;",
+        AstFactory.classTypeAlias(
+            "C",
+            null,
+            Keyword.ABSTRACT,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_generic() {
-    _assertSource("class C<E> = S<E> with M1<E>;", AstFactory.classTypeAlias("C", AstFactory.typeParameterList(["E"]), null, AstFactory.typeName4("S", [AstFactory.typeName4("E")]), AstFactory.withClause([AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]), null));
+    _assertSource(
+        "class C<E> = S<E> with M1<E>;",
+        AstFactory.classTypeAlias(
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            null,
+            AstFactory.typeName4("S", [AstFactory.typeName4("E")]),
+            AstFactory.withClause(
+                [AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]),
+            null));
   }
 
   void test_visitClassTypeAlias_implements() {
-    _assertSource("class C = S with M1 implements I;", AstFactory.classTypeAlias("C", null, null, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), AstFactory.implementsClause([AstFactory.typeName4("I")])));
+    _assertSource(
+        "class C = S with M1 implements I;",
+        AstFactory.classTypeAlias(
+            "C",
+            null,
+            null,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_minimal() {
-    _assertSource("class C = S with M1;", AstFactory.classTypeAlias("C", null, null, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), null));
+    _assertSource(
+        "class C = S with M1;",
+        AstFactory.classTypeAlias(
+            "C",
+            null,
+            null,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            null));
   }
 
   void test_visitClassTypeAlias_parameters_abstract() {
-    _assertSource("abstract class C<E> = S with M1;", AstFactory.classTypeAlias("C", AstFactory.typeParameterList(["E"]), Keyword.ABSTRACT, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), null));
+    _assertSource(
+        "abstract class C<E> = S with M1;",
+        AstFactory.classTypeAlias(
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            Keyword.ABSTRACT,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            null));
   }
 
   void test_visitClassTypeAlias_parameters_abstract_implements() {
-    _assertSource("abstract class C<E> = S with M1 implements I;", AstFactory.classTypeAlias("C", AstFactory.typeParameterList(["E"]), Keyword.ABSTRACT, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), AstFactory.implementsClause([AstFactory.typeName4("I")])));
+    _assertSource(
+        "abstract class C<E> = S with M1 implements I;",
+        AstFactory.classTypeAlias(
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            Keyword.ABSTRACT,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_parameters_implements() {
-    _assertSource("class C<E> = S with M1 implements I;", AstFactory.classTypeAlias("C", AstFactory.typeParameterList(["E"]), null, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), AstFactory.implementsClause([AstFactory.typeName4("I")])));
+    _assertSource(
+        "class C<E> = S with M1 implements I;",
+        AstFactory.classTypeAlias(
+            "C",
+            AstFactory.typeParameterList(["E"]),
+            null,
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_withMetadata() {
-    ClassTypeAlias declaration = AstFactory.classTypeAlias("C", null, null, AstFactory.typeName4("S"), AstFactory.withClause([AstFactory.typeName4("M1")]), null);
-    declaration.metadata = [
-        AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    ClassTypeAlias declaration = AstFactory.classTypeAlias(
+        "C",
+        null,
+        null,
+        AstFactory.typeName4("S"),
+        AstFactory.withClause([AstFactory.typeName4("M1")]),
+        null);
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated class C = S with M1;", declaration);
   }
 
   void test_visitComment() {
-    _assertSource("", Comment.createBlockComment(<Token> [TokenFactory.tokenFromString("/* comment */")]));
+    _assertSource(
+        "",
+        Comment.createBlockComment(
+            <Token>[TokenFactory.tokenFromString("/* comment */")]));
   }
 
   void test_visitCommentReference() {
@@ -1631,19 +2212,30 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitCompilationUnit_declaration() {
-    _assertSource("var a;", AstFactory.compilationUnit2([AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [AstFactory.variableDeclaration("a")])]));
+    _assertSource(
+        "var a;",
+        AstFactory.compilationUnit2(
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitCompilationUnit_directive() {
-    _assertSource("library l;", AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
+    _assertSource(
+        "library l;",
+        AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_directive_declaration() {
-    _assertSource("library l; var a;", AstFactory.compilationUnit4(
-        [AstFactory.libraryDirective2("l")],
-        [AstFactory.topLevelVariableDeclaration2(
-            Keyword.VAR,
-            [AstFactory.variableDeclaration("a")])]));
+    _assertSource(
+        "library l; var a;",
+        AstFactory.compilationUnit4(
+            [AstFactory.libraryDirective2("l")],
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitCompilationUnit_empty() {
@@ -1651,100 +2243,198 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitCompilationUnit_script() {
-    _assertSource("!#/bin/dartvm", AstFactory.compilationUnit5("!#/bin/dartvm"));
+    _assertSource(
+        "!#/bin/dartvm",
+        AstFactory.compilationUnit5("!#/bin/dartvm"));
   }
 
   void test_visitCompilationUnit_script_declaration() {
-    _assertSource("!#/bin/dartvm var a;", AstFactory.compilationUnit6("!#/bin/dartvm", [AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [AstFactory.variableDeclaration("a")])]));
+    _assertSource(
+        "!#/bin/dartvm var a;",
+        AstFactory.compilationUnit6(
+            "!#/bin/dartvm",
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitCompilationUnit_script_directive() {
-    _assertSource("!#/bin/dartvm library l;", AstFactory.compilationUnit7("!#/bin/dartvm", [AstFactory.libraryDirective2("l")]));
+    _assertSource(
+        "!#/bin/dartvm library l;",
+        AstFactory.compilationUnit7(
+            "!#/bin/dartvm",
+            [AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_script_directives_declarations() {
-    _assertSource("!#/bin/dartvm library l; var a;", AstFactory.compilationUnit8(
-        "!#/bin/dartvm",
-        [AstFactory.libraryDirective2("l")],
-        [AstFactory.topLevelVariableDeclaration2(
-            Keyword.VAR,
-            [AstFactory.variableDeclaration("a")])]));
+    _assertSource(
+        "!#/bin/dartvm library l; var a;",
+        AstFactory.compilationUnit8(
+            "!#/bin/dartvm",
+            [AstFactory.libraryDirective2("l")],
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitConditionalExpression() {
-    _assertSource("a ? b : c", AstFactory.conditionalExpression(AstFactory.identifier3("a"), AstFactory.identifier3("b"), AstFactory.identifier3("c")));
+    _assertSource(
+        "a ? b : c",
+        AstFactory.conditionalExpression(
+            AstFactory.identifier3("a"),
+            AstFactory.identifier3("b"),
+            AstFactory.identifier3("c")));
   }
 
   void test_visitConstructorDeclaration_const() {
-    _assertSource("const C() {}", AstFactory.constructorDeclaration2(Keyword.CONST, null, AstFactory.identifier3("C"), null, AstFactory.formalParameterList(), null, AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "const C() {}",
+        AstFactory.constructorDeclaration2(
+            Keyword.CONST,
+            null,
+            AstFactory.identifier3("C"),
+            null,
+            AstFactory.formalParameterList(),
+            null,
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_external() {
-    _assertSource("external C();", AstFactory.constructorDeclaration(AstFactory.identifier3("C"), null, AstFactory.formalParameterList(), null));
+    _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.blockFunctionBody2()));
+    _assertSource(
+        "C() {}",
+        AstFactory.constructorDeclaration2(
+            null,
+            null,
+            AstFactory.identifier3("C"),
+            null,
+            AstFactory.formalParameterList(),
+            null,
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_multipleInitializers() {
-    _assertSource("C() : a = b, c = d {}", AstFactory.constructorDeclaration2(
-        null,
-        null,
-        AstFactory.identifier3("C"),
-        null,
-        AstFactory.formalParameterList(),
-        [
-          AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
-          AstFactory.constructorFieldInitializer(false, "c", AstFactory.identifier3("d"))],
-        AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "C() : a = b, c = d {}",
+        AstFactory.constructorDeclaration2(
+            null,
+            null,
+            AstFactory.identifier3("C"),
+            null,
+            AstFactory.formalParameterList(),
+            [
+                AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
+                AstFactory.constructorFieldInitializer(
+                    false,
+                    "c",
+                    AstFactory.identifier3("d"))],
+            AstFactory.blockFunctionBody2()));
   }
 
   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.blockFunctionBody2()));
+    _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.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_named() {
-    _assertSource("C.m() {}", AstFactory.constructorDeclaration2(null, null, AstFactory.identifier3("C"), "m", AstFactory.formalParameterList(), null, AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "C.m() {}",
+        AstFactory.constructorDeclaration2(
+            null,
+            null,
+            AstFactory.identifier3("C"),
+            "m",
+            AstFactory.formalParameterList(),
+            null,
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_singleInitializer() {
-    _assertSource("C() : a = b {}", AstFactory.constructorDeclaration2(
+    _assertSource(
+        "C() : a = b {}",
+        AstFactory.constructorDeclaration2(
+            null,
+            null,
+            AstFactory.identifier3("C"),
+            null,
+            AstFactory.formalParameterList(),
+            [
+                AstFactory.constructorFieldInitializer(
+                    false,
+                    "a",
+                    AstFactory.identifier3("b"))],
+            AstFactory.blockFunctionBody2()));
+  }
+
+  void test_visitConstructorDeclaration_withMetadata() {
+    ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         null,
         AstFactory.formalParameterList(),
-        [AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b"))],
-        AstFactory.blockFunctionBody2()));
-  }
-
-  void test_visitConstructorDeclaration_withMetadata() {
-    ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(null, null, AstFactory.identifier3("C"), null, AstFactory.formalParameterList(), null, AstFactory.blockFunctionBody2());
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+        null,
+        AstFactory.blockFunctionBody2());
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated C() {}", declaration);
   }
 
   void test_visitConstructorFieldInitializer_withoutThis() {
-    _assertSource("a = b", AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")));
+    _assertSource(
+        "a = b",
+        AstFactory.constructorFieldInitializer(
+            false,
+            "a",
+            AstFactory.identifier3("b")));
   }
 
   void test_visitConstructorFieldInitializer_withThis() {
-    _assertSource("this.a = b", AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
+    _assertSource(
+        "this.a = b",
+        AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
   }
 
   void test_visitConstructorName_named_prefix() {
-    _assertSource("p.C.n", AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null));
+    _assertSource(
+        "p.C.n",
+        AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null));
   }
 
   void test_visitConstructorName_unnamed_noPrefix() {
-    _assertSource("C", AstFactory.constructorName(AstFactory.typeName4("C"), null));
+    _assertSource(
+        "C",
+        AstFactory.constructorName(AstFactory.typeName4("C"), null));
   }
 
   void test_visitConstructorName_unnamed_prefix() {
-    _assertSource("p.C", AstFactory.constructorName(AstFactory.typeName3(AstFactory.identifier5("p", "C")), null));
+    _assertSource(
+        "p.C",
+        AstFactory.constructorName(
+            AstFactory.typeName3(AstFactory.identifier5("p", "C")),
+            null));
   }
 
   void test_visitContinueStatement_label() {
@@ -1756,23 +2446,39 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitDefaultFormalParameter_named_noValue() {
-    _assertSource("p", AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p"), null));
+    _assertSource(
+        "p",
+        AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p"), null));
   }
 
   void test_visitDefaultFormalParameter_named_value() {
-    _assertSource("p : 0", AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0)));
+    _assertSource(
+        "p : 0",
+        AstFactory.namedFormalParameter(
+            AstFactory.simpleFormalParameter3("p"),
+            AstFactory.integer(0)));
   }
 
   void test_visitDefaultFormalParameter_positional_noValue() {
-    _assertSource("p", AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p"), null));
+    _assertSource(
+        "p",
+        AstFactory.positionalFormalParameter(
+            AstFactory.simpleFormalParameter3("p"),
+            null));
   }
 
   void test_visitDefaultFormalParameter_positional_value() {
-    _assertSource("p = 0", AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0)));
+    _assertSource(
+        "p = 0",
+        AstFactory.positionalFormalParameter(
+            AstFactory.simpleFormalParameter3("p"),
+            AstFactory.integer(0)));
   }
 
   void test_visitDoStatement() {
-    _assertSource("do {} while (c);", AstFactory.doStatement(AstFactory.block(), AstFactory.identifier3("c")));
+    _assertSource(
+        "do {} while (c);",
+        AstFactory.doStatement(AstFactory.block(), AstFactory.identifier3("c")));
   }
 
   void test_visitDoubleLiteral() {
@@ -1788,7 +2494,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitEnumDeclaration_multiple() {
-    _assertSource("enum E {ONE, TWO}", AstFactory.enumDeclaration2("E", ["ONE", "TWO"]));
+    _assertSource(
+        "enum E {ONE, TWO}",
+        AstFactory.enumDeclaration2("E", ["ONE", "TWO"]));
   }
 
   void test_visitEnumDeclaration_single() {
@@ -1796,13 +2504,21 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitExportDirective_combinator() {
-    _assertSource("export 'a.dart' show A;", AstFactory.exportDirective2("a.dart", [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+    _assertSource(
+        "export 'a.dart' show A;",
+        AstFactory.exportDirective2(
+            "a.dart",
+            [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   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() {
@@ -1811,66 +2527,126 @@ class ToSourceVisitorTest extends EngineTestCase {
 
   void test_visitExportDirective_withMetadata() {
     ExportDirective directive = AstFactory.exportDirective2("a.dart");
-    directive.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated export 'a.dart';", directive);
   }
 
   void test_visitExpressionFunctionBody_async() {
-    _assertSource("async => a;", AstFactory.asyncExpressionFunctionBody(AstFactory.identifier3("a")));
+    _assertSource(
+        "async => a;",
+        AstFactory.asyncExpressionFunctionBody(AstFactory.identifier3("a")));
   }
 
   void test_visitExpressionFunctionBody_simple() {
-    _assertSource("=> a;", AstFactory.expressionFunctionBody(AstFactory.identifier3("a")));
+    _assertSource(
+        "=> a;",
+        AstFactory.expressionFunctionBody(AstFactory.identifier3("a")));
   }
 
   void test_visitExpressionStatement() {
-    _assertSource("a;", AstFactory.expressionStatement(AstFactory.identifier3("a")));
+    _assertSource(
+        "a;",
+        AstFactory.expressionStatement(AstFactory.identifier3("a")));
   }
 
   void test_visitExtendsClause() {
-    _assertSource("extends C", AstFactory.extendsClause(AstFactory.typeName4("C")));
+    _assertSource(
+        "extends C",
+        AstFactory.extendsClause(AstFactory.typeName4("C")));
   }
 
   void test_visitFieldDeclaration_instance() {
-    _assertSource("var a;", AstFactory.fieldDeclaration2(false, Keyword.VAR, [AstFactory.variableDeclaration("a")]));
+    _assertSource(
+        "var a;",
+        AstFactory.fieldDeclaration2(
+            false,
+            Keyword.VAR,
+            [AstFactory.variableDeclaration("a")]));
   }
 
   void test_visitFieldDeclaration_static() {
-    _assertSource("static var a;", AstFactory.fieldDeclaration2(true, Keyword.VAR, [AstFactory.variableDeclaration("a")]));
+    _assertSource(
+        "static var a;",
+        AstFactory.fieldDeclaration2(
+            true,
+            Keyword.VAR,
+            [AstFactory.variableDeclaration("a")]));
   }
 
   void test_visitFieldDeclaration_withMetadata() {
-    FieldDeclaration declaration = AstFactory.fieldDeclaration2(false, Keyword.VAR, [AstFactory.variableDeclaration("a")]);
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    FieldDeclaration declaration = AstFactory.fieldDeclaration2(
+        false,
+        Keyword.VAR,
+        [AstFactory.variableDeclaration("a")]);
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated var a;", declaration);
   }
 
   void test_visitFieldFormalParameter_functionTyped() {
-    _assertSource("A this.a(b)", AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a", AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
+    _assertSource(
+        "A this.a(b)",
+        AstFactory.fieldFormalParameter(
+            null,
+            AstFactory.typeName4("A"),
+            "a",
+            AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
   }
 
   void test_visitFieldFormalParameter_keyword() {
-    _assertSource("var this.a", AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
+    _assertSource(
+        "var this.a",
+        AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
   }
 
   void test_visitFieldFormalParameter_keywordAndType() {
-    _assertSource("final A this.a", AstFactory.fieldFormalParameter(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
+    _assertSource(
+        "final A this.a",
+        AstFactory.fieldFormalParameter(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitFieldFormalParameter_type() {
-    _assertSource("A this.a", AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a"));
+    _assertSource(
+        "A this.a",
+        AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitForEachStatement_declared() {
-    _assertSource("for (a in b) {}", AstFactory.forEachStatement(AstFactory.declaredIdentifier3("a"), AstFactory.identifier3("b"), AstFactory.block()));
+    _assertSource(
+        "for (a in b) {}",
+        AstFactory.forEachStatement(
+            AstFactory.declaredIdentifier3("a"),
+            AstFactory.identifier3("b"),
+            AstFactory.block()));
   }
 
   void test_visitForEachStatement_variable() {
-    _assertSource("for (a in b) {}", new ForEachStatement.con2(null, TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), AstFactory.identifier3("a"), TokenFactory.tokenFromKeyword(Keyword.IN), AstFactory.identifier3("b"), TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), AstFactory.block()));
+    _assertSource(
+        "for (a in b) {}",
+        new ForEachStatement.con2(
+            null,
+            TokenFactory.tokenFromKeyword(Keyword.FOR),
+            TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
+            AstFactory.identifier3("a"),
+            TokenFactory.tokenFromKeyword(Keyword.IN),
+            AstFactory.identifier3("b"),
+            TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
+            AstFactory.block()));
   }
 
   void test_visitForEachStatement_variable_await() {
-    _assertSource("await for (a in b) {}", new ForEachStatement.con2(TokenFactory.tokenFromString("await"), TokenFactory.tokenFromKeyword(Keyword.FOR), TokenFactory.tokenFromType(TokenType.OPEN_PAREN), AstFactory.identifier3("a"), TokenFactory.tokenFromKeyword(Keyword.IN), AstFactory.identifier3("b"), TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), AstFactory.block()));
+    _assertSource(
+        "await for (a in b) {}",
+        new ForEachStatement.con2(
+            TokenFactory.tokenFromString("await"),
+            TokenFactory.tokenFromKeyword(Keyword.FOR),
+            TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
+            AstFactory.identifier3("a"),
+            TokenFactory.tokenFromKeyword(Keyword.IN),
+            AstFactory.identifier3("b"),
+            TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
+            AstFactory.block()));
   }
 
   void test_visitFormalParameterList_empty() {
@@ -1878,171 +2654,379 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitFormalParameterList_n() {
-    _assertSource("({a : 0})", AstFactory.formalParameterList([AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0))]));
+    _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))]));
+    _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")]));
+    _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, AstFactory.identifier3("c"), null, AstFactory.block()));
+    _assertSource(
+        "for (; c;) {}",
+        AstFactory.forStatement(
+            null,
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
   }
 
   void test_visitForStatement_cu() {
-    _assertSource("for (; c; u) {}", AstFactory.forStatement(null, AstFactory.identifier3("c"), [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (; c; u) {}",
+        AstFactory.forStatement(
+            null,
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_e() {
-    _assertSource("for (e;;) {}", AstFactory.forStatement(AstFactory.identifier3("e"), null, null, AstFactory.block()));
+    _assertSource(
+        "for (e;;) {}",
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            null,
+            null,
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ec() {
-    _assertSource("for (e; c;) {}", AstFactory.forStatement(AstFactory.identifier3("e"), AstFactory.identifier3("c"), null, AstFactory.block()));
+    _assertSource(
+        "for (e; c;) {}",
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ecu() {
-    _assertSource("for (e; c; u) {}", AstFactory.forStatement(AstFactory.identifier3("e"), AstFactory.identifier3("c"), [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (e; c; u) {}",
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_eu() {
-    _assertSource("for (e;; u) {}", AstFactory.forStatement(AstFactory.identifier3("e"), null, [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (e;; u) {}",
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_i() {
-    _assertSource("for (var i;;) {}", AstFactory.forStatement2(AstFactory.variableDeclarationList2(Keyword.VAR, [AstFactory.variableDeclaration("i")]), null, null, AstFactory.block()));
+    _assertSource(
+        "for (var i;;) {}",
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            null,
+            null,
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ic() {
-    _assertSource("for (var i; c;) {}", AstFactory.forStatement2(AstFactory.variableDeclarationList2(Keyword.VAR, [AstFactory.variableDeclaration("i")]), AstFactory.identifier3("c"), null, AstFactory.block()));
+    _assertSource(
+        "for (var i; c;) {}",
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
   }
 
   void test_visitForStatement_icu() {
-    _assertSource("for (var i; c; u) {}", AstFactory.forStatement2(AstFactory.variableDeclarationList2(Keyword.VAR, [AstFactory.variableDeclaration("i")]), AstFactory.identifier3("c"), [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (var i; c; u) {}",
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_iu() {
-    _assertSource("for (var i;; u) {}", AstFactory.forStatement2(AstFactory.variableDeclarationList2(Keyword.VAR, [AstFactory.variableDeclaration("i")]), null, [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (var i;; u) {}",
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_u() {
-    _assertSource("for (;; u) {}", AstFactory.forStatement(null, null, [AstFactory.identifier3("u")], AstFactory.block()));
+    _assertSource(
+        "for (;; u) {}",
+        AstFactory.forStatement(
+            null,
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitFunctionDeclaration_getter() {
-    _assertSource("get f() {}", AstFactory.functionDeclaration(null, Keyword.GET, "f", AstFactory.functionExpression()));
+    _assertSource(
+        "get f() {}",
+        AstFactory.functionDeclaration(
+            null,
+            Keyword.GET,
+            "f",
+            AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_local_blockBody() {
-    FunctionDeclaration f = AstFactory.functionDeclaration(null, null, "f", AstFactory.functionExpression());
-    FunctionDeclarationStatement fStatement = new FunctionDeclarationStatement(f);
-    _assertSource("main() {f() {} 42;}", AstFactory.functionDeclaration(null, null, "main", AstFactory.functionExpression2(AstFactory.formalParameterList(), AstFactory.blockFunctionBody2([
-        fStatement,
-        AstFactory.expressionStatement(AstFactory.integer(42))]))));
+    FunctionDeclaration f = AstFactory.functionDeclaration(
+        null,
+        null,
+        "f",
+        AstFactory.functionExpression());
+    FunctionDeclarationStatement fStatement =
+        new FunctionDeclarationStatement(f);
+    _assertSource(
+        "main() {f() {} 42;}",
+        AstFactory.functionDeclaration(
+            null,
+            null,
+            "main",
+            AstFactory.functionExpression2(
+                AstFactory.formalParameterList(),
+                AstFactory.blockFunctionBody2(
+                    [fStatement, AstFactory.expressionStatement(AstFactory.integer(42))]))));
   }
 
   void test_visitFunctionDeclaration_local_expressionBody() {
-    FunctionDeclaration f = AstFactory.functionDeclaration(null, null, "f", AstFactory.functionExpression2(AstFactory.formalParameterList(), AstFactory.expressionFunctionBody(AstFactory.integer(1))));
-    FunctionDeclarationStatement fStatement = new FunctionDeclarationStatement(f);
-    _assertSource("main() {f() => 1; 2;}", AstFactory.functionDeclaration(null, null, "main", AstFactory.functionExpression2(AstFactory.formalParameterList(), AstFactory.blockFunctionBody2([
-        fStatement,
-        AstFactory.expressionStatement(AstFactory.integer(2))]))));
+    FunctionDeclaration f = AstFactory.functionDeclaration(
+        null,
+        null,
+        "f",
+        AstFactory.functionExpression2(
+            AstFactory.formalParameterList(),
+            AstFactory.expressionFunctionBody(AstFactory.integer(1))));
+    FunctionDeclarationStatement fStatement =
+        new FunctionDeclarationStatement(f);
+    _assertSource(
+        "main() {f() => 1; 2;}",
+        AstFactory.functionDeclaration(
+            null,
+            null,
+            "main",
+            AstFactory.functionExpression2(
+                AstFactory.formalParameterList(),
+                AstFactory.blockFunctionBody2(
+                    [fStatement, AstFactory.expressionStatement(AstFactory.integer(2))]))));
   }
 
   void test_visitFunctionDeclaration_normal() {
-    _assertSource("f() {}", AstFactory.functionDeclaration(null, null, "f", AstFactory.functionExpression()));
+    _assertSource(
+        "f() {}",
+        AstFactory.functionDeclaration(
+            null,
+            null,
+            "f",
+            AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_setter() {
-    _assertSource("set f() {}", AstFactory.functionDeclaration(null, Keyword.SET, "f", AstFactory.functionExpression()));
+    _assertSource(
+        "set f() {}",
+        AstFactory.functionDeclaration(
+            null,
+            Keyword.SET,
+            "f",
+            AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_withMetadata() {
-    FunctionDeclaration declaration = AstFactory.functionDeclaration(null, null, "f", AstFactory.functionExpression());
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    FunctionDeclaration declaration = AstFactory.functionDeclaration(
+        null,
+        null,
+        "f",
+        AstFactory.functionExpression());
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated f() {}", declaration);
   }
 
   void test_visitFunctionDeclarationStatement() {
-    _assertSource("f() {}", AstFactory.functionDeclarationStatement(null, null, "f", AstFactory.functionExpression()));
+    _assertSource(
+        "f() {}",
+        AstFactory.functionDeclarationStatement(
+            null,
+            null,
+            "f",
+            AstFactory.functionExpression()));
   }
 
   void test_visitFunctionExpression() {
@@ -2050,20 +3034,39 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitFunctionExpressionInvocation() {
-    _assertSource("f()", AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
+    _assertSource(
+        "f()",
+        AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
   }
 
   void test_visitFunctionTypeAlias_generic() {
-    _assertSource("typedef A F<B>();", AstFactory.typeAlias(AstFactory.typeName4("A"), "F", AstFactory.typeParameterList(["B"]), AstFactory.formalParameterList()));
+    _assertSource(
+        "typedef A F<B>();",
+        AstFactory.typeAlias(
+            AstFactory.typeName4("A"),
+            "F",
+            AstFactory.typeParameterList(["B"]),
+            AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_nonGeneric() {
-    _assertSource("typedef A F();", AstFactory.typeAlias(AstFactory.typeName4("A"), "F", null, AstFactory.formalParameterList()));
+    _assertSource(
+        "typedef A F();",
+        AstFactory.typeAlias(
+            AstFactory.typeName4("A"),
+            "F",
+            null,
+            AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_withMetadata() {
-    FunctionTypeAlias declaration = AstFactory.typeAlias(AstFactory.typeName4("A"), "F", null, AstFactory.formalParameterList());
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    FunctionTypeAlias declaration = AstFactory.typeAlias(
+        AstFactory.typeName4("A"),
+        "F",
+        null,
+        AstFactory.formalParameterList());
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated typedef A F();", declaration);
   }
 
@@ -2072,95 +3075,159 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
-    _assertSource("T f()", AstFactory.functionTypedFormalParameter(AstFactory.typeName4("T"), "f"));
+    _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()));
+    _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()));
+    _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")]));
+    _assertSource(
+        "implements A",
+        AstFactory.implementsClause([AstFactory.typeName4("A")]));
   }
 
   void test_visitImportDirective_combinator() {
-    _assertSource("import 'a.dart' show A;", AstFactory.importDirective3("a.dart", null, [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+    _assertSource(
+        "import 'a.dart' show A;",
+        AstFactory.importDirective3(
+            "a.dart",
+            null,
+            [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_combinators() {
-    _assertSource("import 'a.dart' show A hide B;", AstFactory.importDirective3("a.dart", null, [
-        AstFactory.showCombinator([AstFactory.identifier3("A")]),
-        AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
+    _assertSource(
+        "import 'a.dart' show A hide B;",
+        AstFactory.importDirective3(
+            "a.dart",
+            null,
+            [
+                AstFactory.showCombinator([AstFactory.identifier3("A")]),
+                AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitImportDirective_deferred() {
-    _assertSource("import 'a.dart' deferred as p;", AstFactory.importDirective2("a.dart", true, "p"));
+    _assertSource(
+        "import 'a.dart' deferred as p;",
+        AstFactory.importDirective2("a.dart", true, "p"));
   }
 
   void test_visitImportDirective_minimal() {
-    _assertSource("import 'a.dart';", AstFactory.importDirective3("a.dart", null));
+    _assertSource(
+        "import 'a.dart';",
+        AstFactory.importDirective3("a.dart", null));
   }
 
   void test_visitImportDirective_prefix() {
-    _assertSource("import 'a.dart' as p;", AstFactory.importDirective3("a.dart", "p"));
+    _assertSource(
+        "import 'a.dart' as p;",
+        AstFactory.importDirective3("a.dart", "p"));
   }
 
   void test_visitImportDirective_prefix_combinator() {
-    _assertSource("import 'a.dart' as p show A;", AstFactory.importDirective3("a.dart", "p", [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+    _assertSource(
+        "import 'a.dart' as p show A;",
+        AstFactory.importDirective3(
+            "a.dart",
+            "p",
+            [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_prefix_combinators() {
-    _assertSource("import 'a.dart' as p show A hide B;", AstFactory.importDirective3("a.dart", "p", [
-        AstFactory.showCombinator([AstFactory.identifier3("A")]),
-        AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
+    _assertSource(
+        "import 'a.dart' as p show A hide B;",
+        AstFactory.importDirective3(
+            "a.dart",
+            "p",
+            [
+                AstFactory.showCombinator([AstFactory.identifier3("A")]),
+                AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitImportDirective_withMetadata() {
     ImportDirective directive = AstFactory.importDirective3("a.dart", null);
-    directive.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated import 'a.dart';", directive);
   }
 
   void test_visitImportHideCombinator_multiple() {
-    _assertSource("hide a, b", AstFactory.hideCombinator([AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+    _assertSource(
+        "hide a, b",
+        AstFactory.hideCombinator(
+            [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitImportHideCombinator_single() {
-    _assertSource("hide a", AstFactory.hideCombinator([AstFactory.identifier3("a")]));
+    _assertSource(
+        "hide a",
+        AstFactory.hideCombinator([AstFactory.identifier3("a")]));
   }
 
   void test_visitImportShowCombinator_multiple() {
-    _assertSource("show a, b", AstFactory.showCombinator([AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+    _assertSource(
+        "show a, b",
+        AstFactory.showCombinator(
+            [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitImportShowCombinator_single() {
-    _assertSource("show a", AstFactory.showCombinator([AstFactory.identifier3("a")]));
+    _assertSource(
+        "show a",
+        AstFactory.showCombinator([AstFactory.identifier3("a")]));
   }
 
   void test_visitIndexExpression() {
-    _assertSource("a[i]", AstFactory.indexExpression(AstFactory.identifier3("a"), AstFactory.identifier3("i")));
+    _assertSource(
+        "a[i]",
+        AstFactory.indexExpression(
+            AstFactory.identifier3("a"),
+            AstFactory.identifier3("i")));
   }
 
   void test_visitInstanceCreationExpression_const() {
-    _assertSource("const C()", AstFactory.instanceCreationExpression2(Keyword.CONST, AstFactory.typeName4("C")));
+    _assertSource(
+        "const C()",
+        AstFactory.instanceCreationExpression2(
+            Keyword.CONST,
+            AstFactory.typeName4("C")));
   }
 
   void test_visitInstanceCreationExpression_named() {
-    _assertSource("new C.c()", AstFactory.instanceCreationExpression3(Keyword.NEW, AstFactory.typeName4("C"), "c"));
+    _assertSource(
+        "new C.c()",
+        AstFactory.instanceCreationExpression3(
+            Keyword.NEW,
+            AstFactory.typeName4("C"),
+            "c"));
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
-    _assertSource("new C()", AstFactory.instanceCreationExpression2(Keyword.NEW, AstFactory.typeName4("C")));
+    _assertSource(
+        "new C()",
+        AstFactory.instanceCreationExpression2(Keyword.NEW, AstFactory.typeName4("C")));
   }
 
   void test_visitIntegerLiteral() {
@@ -2168,7 +3235,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitInterpolationExpression_expression() {
-    _assertSource("\${a}", AstFactory.interpolationExpression(AstFactory.identifier3("a")));
+    _assertSource(
+        "\${a}",
+        AstFactory.interpolationExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitInterpolationExpression_identifier() {
@@ -2180,11 +3249,21 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitIsExpression_negated() {
-    _assertSource("a is! C", AstFactory.isExpression(AstFactory.identifier3("a"), true, AstFactory.typeName4("C")));
+    _assertSource(
+        "a is! C",
+        AstFactory.isExpression(
+            AstFactory.identifier3("a"),
+            true,
+            AstFactory.typeName4("C")));
   }
 
   void test_visitIsExpression_normal() {
-    _assertSource("a is C", AstFactory.isExpression(AstFactory.identifier3("a"), false, AstFactory.typeName4("C")));
+    _assertSource(
+        "a is C",
+        AstFactory.isExpression(
+            AstFactory.identifier3("a"),
+            false,
+            AstFactory.typeName4("C")));
   }
 
   void test_visitLabel() {
@@ -2192,11 +3271,19 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitLabeledStatement_multiple() {
-    _assertSource("a: b: return;", AstFactory.labeledStatement([AstFactory.label2("a"), AstFactory.label2("b")], AstFactory.returnStatement()));
+    _assertSource(
+        "a: b: return;",
+        AstFactory.labeledStatement(
+            [AstFactory.label2("a"), AstFactory.label2("b")],
+            AstFactory.returnStatement()));
   }
 
   void test_visitLabeledStatement_single() {
-    _assertSource("a: return;", AstFactory.labeledStatement([AstFactory.label2("a")], AstFactory.returnStatement()));
+    _assertSource(
+        "a: return;",
+        AstFactory.labeledStatement(
+            [AstFactory.label2("a")],
+            AstFactory.returnStatement()));
   }
 
   void test_visitLibraryDirective() {
@@ -2205,19 +3292,25 @@ class ToSourceVisitorTest extends EngineTestCase {
 
   void test_visitLibraryDirective_withMetadata() {
     LibraryDirective directive = AstFactory.libraryDirective2("l");
-    directive.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated library l;", directive);
   }
 
   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")]));
+    _assertSource(
+        "a",
+        AstFactory.libraryIdentifier([AstFactory.identifier3("a")]));
   }
 
   void test_visitListLiteral_const() {
@@ -2229,10 +3322,13 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   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() {
@@ -2244,73 +3340,204 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   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")));
+    _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()));
+    _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()));
+    _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.blockFunctionBody2()));
+    _assertSource(
+        "get m {}",
+        AstFactory.methodDeclaration2(
+            null,
+            null,
+            Keyword.GET,
+            null,
+            AstFactory.identifier3("m"),
+            null,
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_getter_returnType() {
-    _assertSource("T get m {}", AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"), Keyword.GET, null, AstFactory.identifier3("m"), null, AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "T get m {}",
+        AstFactory.methodDeclaration2(
+            null,
+            AstFactory.typeName4("T"),
+            Keyword.GET,
+            null,
+            AstFactory.identifier3("m"),
+            null,
+            AstFactory.blockFunctionBody2()));
   }
 
   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.blockFunctionBody2()));
+    _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.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_minimal() {
-    _assertSource("m() {}", AstFactory.methodDeclaration2(null, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "m() {}",
+        AstFactory.methodDeclaration2(
+            null,
+            null,
+            null,
+            null,
+            AstFactory.identifier3("m"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   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.blockFunctionBody2()));
+    _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.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_operator() {
-    _assertSource("operator +() {}", AstFactory.methodDeclaration2(null, null, null, Keyword.OPERATOR, AstFactory.identifier3("+"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "operator +() {}",
+        AstFactory.methodDeclaration2(
+            null,
+            null,
+            null,
+            Keyword.OPERATOR,
+            AstFactory.identifier3("+"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_operator_returnType() {
-    _assertSource("T operator +() {}", AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"), null, Keyword.OPERATOR, AstFactory.identifier3("+"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "T operator +() {}",
+        AstFactory.methodDeclaration2(
+            null,
+            AstFactory.typeName4("T"),
+            null,
+            Keyword.OPERATOR,
+            AstFactory.identifier3("+"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_returnType() {
-    _assertSource("T m() {}", AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"), null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "T m() {}",
+        AstFactory.methodDeclaration2(
+            null,
+            AstFactory.typeName4("T"),
+            null,
+            null,
+            AstFactory.identifier3("m"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_setter() {
-    _assertSource("set m(var v) {}", AstFactory.methodDeclaration2(null, null, Keyword.SET, null, AstFactory.identifier3("m"), AstFactory.formalParameterList([AstFactory.simpleFormalParameter(Keyword.VAR, "v")]), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "set m(var v) {}",
+        AstFactory.methodDeclaration2(
+            null,
+            null,
+            Keyword.SET,
+            null,
+            AstFactory.identifier3("m"),
+            AstFactory.formalParameterList(
+                [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_static() {
-    _assertSource("static m() {}", AstFactory.methodDeclaration2(Keyword.STATIC, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "static m() {}",
+        AstFactory.methodDeclaration2(
+            Keyword.STATIC,
+            null,
+            null,
+            null,
+            AstFactory.identifier3("m"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_static_returnType() {
-    _assertSource("static T m() {}", AstFactory.methodDeclaration2(Keyword.STATIC, AstFactory.typeName4("T"), null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
+    _assertSource(
+        "static T m() {}",
+        AstFactory.methodDeclaration2(
+            Keyword.STATIC,
+            AstFactory.typeName4("T"),
+            null,
+            null,
+            AstFactory.identifier3("m"),
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_withMetadata() {
-    MethodDeclaration declaration = AstFactory.methodDeclaration2(null, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.blockFunctionBody2());
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    MethodDeclaration declaration = AstFactory.methodDeclaration2(
+        null,
+        null,
+        null,
+        null,
+        AstFactory.identifier3("m"),
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated m() {}", declaration);
   }
 
@@ -2319,15 +3546,23 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitMethodInvocation_target() {
-    _assertSource("t.m()", AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
+    _assertSource(
+        "t.m()",
+        AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
   }
 
   void test_visitNamedExpression() {
-    _assertSource("a: b", AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
+    _assertSource(
+        "a: b",
+        AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitNamedFormalParameter() {
-    _assertSource("var a : 0", AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter(Keyword.VAR, "a"), AstFactory.integer(0)));
+    _assertSource(
+        "var a : 0",
+        AstFactory.namedFormalParameter(
+            AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+            AstFactory.integer(0)));
   }
 
   void test_visitNativeClause() {
@@ -2343,7 +3578,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitParenthesizedExpression() {
-    _assertSource("(a)", AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
+    _assertSource(
+        "(a)",
+        AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitPartDirective() {
@@ -2352,26 +3589,37 @@ class ToSourceVisitorTest extends EngineTestCase {
 
   void test_visitPartDirective_withMetadata() {
     PartDirective directive = AstFactory.partDirective2("a.dart");
-    directive.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    directive.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated part 'a.dart';", directive);
   }
 
   void test_visitPartOfDirective() {
-    _assertSource("part of l;", AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])));
+    _assertSource(
+        "part of l;",
+        AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])));
   }
 
   void test_visitPartOfDirective_withMetadata() {
-    PartOfDirective directive = AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
-    directive.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    PartOfDirective directive =
+        AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
+    directive.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated part of l;", directive);
   }
 
   void test_visitPositionalFormalParameter() {
-    _assertSource("var a = 0", AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter(Keyword.VAR, "a"), AstFactory.integer(0)));
+    _assertSource(
+        "var a = 0",
+        AstFactory.positionalFormalParameter(
+            AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+            AstFactory.integer(0)));
   }
 
   void test_visitPostfixExpression() {
-    _assertSource("a++", AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
+    _assertSource(
+        "a++",
+        AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
   }
 
   void test_visitPrefixedIdentifier() {
@@ -2379,15 +3627,21 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitPrefixExpression() {
-    _assertSource("-a", AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
+    _assertSource(
+        "-a",
+        AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
   }
 
   void test_visitPropertyAccess() {
-    _assertSource("a.b", AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b"));
+    _assertSource(
+        "a.b",
+        AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b"));
   }
 
   void test_visitRedirectingConstructorInvocation_named() {
-    _assertSource("this.c()", AstFactory.redirectingConstructorInvocation2("c"));
+    _assertSource(
+        "this.c()",
+        AstFactory.redirectingConstructorInvocation2("c"));
   }
 
   void test_visitRedirectingConstructorInvocation_unnamed() {
@@ -2399,7 +3653,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitReturnStatement_expression() {
-    _assertSource("return a;", AstFactory.returnStatement2(AstFactory.identifier3("a")));
+    _assertSource(
+        "return a;",
+        AstFactory.returnStatement2(AstFactory.identifier3("a")));
   }
 
   void test_visitReturnStatement_noExpression() {
@@ -2416,11 +3672,18 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitSimpleFormalParameter_keyword_type() {
-    _assertSource("final A a", AstFactory.simpleFormalParameter2(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
+    _assertSource(
+        "final A a",
+        AstFactory.simpleFormalParameter2(
+            Keyword.FINAL,
+            AstFactory.typeName4("A"),
+            "a"));
   }
 
   void test_visitSimpleFormalParameter_type() {
-    _assertSource("A a", AstFactory.simpleFormalParameter4(AstFactory.typeName4("A"), "a"));
+    _assertSource(
+        "A a",
+        AstFactory.simpleFormalParameter4(AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitSimpleIdentifier() {
@@ -2432,10 +3695,13 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   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() {
@@ -2451,41 +3717,71 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitSwitchCase_multipleLabels() {
-    _assertSource("l1: l2: case a: {}", AstFactory.switchCase2([AstFactory.label2("l1"), AstFactory.label2("l2")], AstFactory.identifier3("a"), [AstFactory.block()]));
+    _assertSource(
+        "l1: l2: case a: {}",
+        AstFactory.switchCase2(
+            [AstFactory.label2("l1"), AstFactory.label2("l2")],
+            AstFactory.identifier3("a"),
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_multipleStatements() {
-    _assertSource("case a: {} {}", AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block(), AstFactory.block()]));
+    _assertSource(
+        "case a: {} {}",
+        AstFactory.switchCase(
+            AstFactory.identifier3("a"),
+            [AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchCase_noLabels() {
-    _assertSource("case a: {}", AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
+    _assertSource(
+        "case a: {}",
+        AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_singleLabel() {
-    _assertSource("l1: case a: {}", AstFactory.switchCase2([AstFactory.label2("l1")], AstFactory.identifier3("a"), [AstFactory.block()]));
+    _assertSource(
+        "l1: case a: {}",
+        AstFactory.switchCase2(
+            [AstFactory.label2("l1")],
+            AstFactory.identifier3("a"),
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleLabels() {
-    _assertSource("l1: l2: default: {}", AstFactory.switchDefault([AstFactory.label2("l1"), AstFactory.label2("l2")], [AstFactory.block()]));
+    _assertSource(
+        "l1: l2: default: {}",
+        AstFactory.switchDefault(
+            [AstFactory.label2("l1"), AstFactory.label2("l2")],
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleStatements() {
-    _assertSource("default: {} {}", AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
+    _assertSource(
+        "default: {} {}",
+        AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_noLabels() {
-    _assertSource("default: {}", AstFactory.switchDefault2([AstFactory.block()]));
+    _assertSource(
+        "default: {}",
+        AstFactory.switchDefault2([AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_singleLabel() {
-    _assertSource("l1: default: {}", AstFactory.switchDefault([AstFactory.label2("l1")], [AstFactory.block()]));
+    _assertSource(
+        "l1: default: {}",
+        AstFactory.switchDefault([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() {
@@ -2501,55 +3797,87 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitThrowStatement() {
-    _assertSource("throw e", AstFactory.throwExpression2(AstFactory.identifier3("e")));
+    _assertSource(
+        "throw e",
+        AstFactory.throwExpression2(AstFactory.identifier3("e")));
   }
 
   void test_visitTopLevelVariableDeclaration_multiple() {
-    _assertSource("var a;", AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [AstFactory.variableDeclaration("a")]));
+    _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"))]));
+    _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.catchClause3(AstFactory.typeName4("E"))], AstFactory.block()));
+    _assertSource(
+        "try {} on E {} finally {}",
+        AstFactory.tryStatement3(
+            AstFactory.block(),
+            [AstFactory.catchClause3(AstFactory.typeName4("E"))],
+            AstFactory.block()));
   }
 
   void test_visitTryStatement_finally() {
-    _assertSource("try {} finally {}", AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
+    _assertSource(
+        "try {} finally {}",
+        AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
   }
 
   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")]));
+    _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")])]));
+    _assertSource(
+        "C<D<E>>",
+        AstFactory.typeName4(
+            "C",
+            [AstFactory.typeName4("D", [AstFactory.typeName4("E")])]));
   }
 
   void test_visitTypeName_noArgs() {
@@ -2557,16 +3885,21 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitTypeName_singleArg() {
-    _assertSource("C<D>", AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
+    _assertSource(
+        "C<D>",
+        AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
   }
 
   void test_visitTypeParameter_withExtends() {
-    _assertSource("E extends C", AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
+    _assertSource(
+        "E extends C",
+        AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
   }
 
   void test_visitTypeParameter_withMetadata() {
     TypeParameter parameter = AstFactory.typeParameter("E");
-    parameter.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    parameter.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated E", parameter);
   }
 
@@ -2583,7 +3916,9 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitVariableDeclaration_initialized() {
-    _assertSource("a = b", AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
+    _assertSource(
+        "a = b",
+        AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitVariableDeclaration_uninitialized() {
@@ -2592,55 +3927,78 @@ class ToSourceVisitorTest extends EngineTestCase {
 
   void test_visitVariableDeclaration_withMetadata() {
     VariableDeclaration declaration = AstFactory.variableDeclaration("a");
-    declaration.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated a", declaration);
   }
 
   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_final_withMetadata() {
-    VariableDeclarationList declarationList = AstFactory.variableDeclarationList2(Keyword.FINAL, [
-        AstFactory.variableDeclaration("a"),
-        AstFactory.variableDeclaration("b")]);
-    declarationList.metadata = [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    VariableDeclarationList declarationList =
+        AstFactory.variableDeclarationList2(
+            Keyword.FINAL,
+            [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]);
+    declarationList.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertSource("@deprecated final a, b", declarationList);
   }
 
   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")]));
+    _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()));
+    _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() {
@@ -2648,11 +4006,15 @@ class ToSourceVisitorTest extends EngineTestCase {
   }
 
   void test_visitYieldStatement() {
-    _assertSource("yield e;", AstFactory.yieldStatement(AstFactory.identifier3("e")));
+    _assertSource(
+        "yield e;",
+        AstFactory.yieldStatement(AstFactory.identifier3("e")));
   }
 
   void test_visitYieldStatement_each() {
-    _assertSource("yield* e;", AstFactory.yieldEachStatement(AstFactory.identifier3("e")));
+    _assertSource(
+        "yield* e;",
+        AstFactory.yieldEachStatement(AstFactory.identifier3("e")));
   }
 
   /**
@@ -2673,7 +4035,8 @@ class ToSourceVisitorTest extends EngineTestCase {
 class VariableDeclarationTest extends ParserTestCase {
   void test_getDocumentationComment_onGrandParent() {
     VariableDeclaration varDecl = AstFactory.variableDeclaration("a");
-    TopLevelVariableDeclaration decl = AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [varDecl]);
+    TopLevelVariableDeclaration decl =
+        AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [varDecl]);
     Comment comment = Comment.createDocumentationComment(new List<Token>(0));
     expect(varDecl.documentationComment, isNull);
     decl.documentationComment = comment;
@@ -2690,13 +4053,17 @@ class VariableDeclarationTest extends ParserTestCase {
 }
 
 class WrapperKind extends Enum<WrapperKind> {
-  static const WrapperKind PREFIXED_LEFT = const WrapperKind('PREFIXED_LEFT', 0);
+  static const WrapperKind PREFIXED_LEFT =
+      const WrapperKind('PREFIXED_LEFT', 0);
 
-  static const WrapperKind PREFIXED_RIGHT = const WrapperKind('PREFIXED_RIGHT', 1);
+  static const WrapperKind PREFIXED_RIGHT =
+      const WrapperKind('PREFIXED_RIGHT', 1);
 
-  static const WrapperKind PROPERTY_LEFT = const WrapperKind('PROPERTY_LEFT', 2);
+  static const WrapperKind PROPERTY_LEFT =
+      const WrapperKind('PROPERTY_LEFT', 2);
 
-  static const WrapperKind PROPERTY_RIGHT = const WrapperKind('PROPERTY_RIGHT', 3);
+  static const WrapperKind PROPERTY_RIGHT =
+      const WrapperKind('PROPERTY_RIGHT', 3);
 
   static const WrapperKind NONE = const WrapperKind('NONE', 4);
 
@@ -2709,20 +4076,3 @@ class WrapperKind extends Enum<WrapperKind> {
 
   const WrapperKind(String name, int ordinal) : super(name, ordinal);
 }
-
-main() {
-  groupSep = ' | ';
-  runReflectiveTests(BreadthFirstVisitorTest);
-  runReflectiveTests(ClassDeclarationTest);
-  runReflectiveTests(ClassTypeAliasTest);
-  runReflectiveTests(ConstantEvaluatorTest);
-  runReflectiveTests(ConstructorDeclarationTest);
-  runReflectiveTests(IndexExpressionTest);
-  runReflectiveTests(NodeListTest);
-  runReflectiveTests(NodeLocatorTest);
-  runReflectiveTests(SimpleIdentifierTest);
-  runReflectiveTests(SimpleStringLiteralTest);
-  runReflectiveTests(StringInterpolationTest);
-  runReflectiveTests(ToSourceVisitorTest);
-  runReflectiveTests(VariableDeclarationTest);
-}