Create fewer unnecessary lists

pkg/analyzer/test/generated/utilities_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.utilities_test;
 
 import 'dart:collection';
@@ skipping 34 matching lines @@
 
   void test_visitAnnotation_constant() {
     _assertClone(AstFactory.annotation(AstFactory.identifier3("A")));
   }
 
   void test_visitAnnotation_constructor() {
     _assertClone(
         AstFactory.annotation2(
             AstFactory.identifier3("A"),
             AstFactory.identifier3("c"),
-            AstFactory.argumentList([])));
+            AstFactory.argumentList()));
   }
 
   void test_visitArgumentList() {
     _assertClone(
         AstFactory.argumentList(
             [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitAsExpression() {
     _assertClone(
         AstFactory.asExpression(
             AstFactory.identifier3("e"),
-            AstFactory.typeName4("T", [])));
+            AstFactory.typeName4("T")));
   }
 
   void test_visitAssertStatement() {
     _assertClone(AstFactory.assertStatement(AstFactory.identifier3("a")));
   }
 
   void test_visitAssignmentExpression() {
     _assertClone(
         AstFactory.assignmentExpression(
             AstFactory.identifier3("a"),
             TokenType.EQ,
             AstFactory.identifier3("b")));
   }
 
   void test_visitAwaitExpression() {
     _assertClone(AstFactory.awaitExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitBinaryExpression() {
     _assertClone(
         AstFactory.binaryExpression(
             AstFactory.identifier3("a"),
             TokenType.PLUS,
             AstFactory.identifier3("b")));
   }
 
   void test_visitBlockFunctionBody() {
-    _assertClone(AstFactory.blockFunctionBody2([]));
+    _assertClone(AstFactory.blockFunctionBody2());
   }
 
   void test_visitBlock_empty() {
-    _assertClone(AstFactory.block([]));
+    _assertClone(AstFactory.block());
   }
 
   void test_visitBlock_nonEmpty() {
     _assertClone(
         AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
   }
 
   void test_visitBooleanLiteral_false() {
     _assertClone(AstFactory.booleanLiteral(false));
   }
@@ skipping 26 matching lines @@
             [
                 AstFactory.cascadedIndexExpression(AstFactory.integer(0)),
                 AstFactory.cascadedIndexExpression(AstFactory.integer(1))]));
   }
 
   void test_visitCascadeExpression_method() {
     _assertClone(
         AstFactory.cascadeExpression(
             AstFactory.identifier3("a"),
             [
-                AstFactory.cascadedMethodInvocation("b", []),
-                AstFactory.cascadedMethodInvocation("c", [])]));
+                AstFactory.cascadedMethodInvocation("b"),
+                AstFactory.cascadedMethodInvocation("c")]));
   }
 
   void test_visitCatchClause_catch_noStack() {
-    _assertClone(AstFactory.catchClause("e", []));
+    _assertClone(AstFactory.catchClause("e"));
   }
 
   void test_visitCatchClause_catch_stack() {
-    _assertClone(AstFactory.catchClause2("e", "s", []));
+    _assertClone(AstFactory.catchClause2("e", "s"));
   }
 
   void test_visitCatchClause_on() {
-    _assertClone(AstFactory.catchClause3(AstFactory.typeName4("E", []), []));
+    _assertClone(AstFactory.catchClause3(AstFactory.typeName4("E")));
   }
 
   void test_visitCatchClause_on_catch() {
     _assertClone(
-        AstFactory.catchClause4(AstFactory.typeName4("E", []), "e", []));
+        AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
   }
 
   void test_visitClassDeclaration_abstract() {
     _assertClone(
-        AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null, []));
+        AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
   }
 
   void test_visitClassDeclaration_empty() {
     _assertClone(
-        AstFactory.classDeclaration(null, "C", null, null, null, null, []));
+        AstFactory.classDeclaration(null, "C", null, null, null, null));
   }
 
   void test_visitClassDeclaration_extends() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
             null,
-            null,
-            []));
+            null));
   }
 
   void test_visitClassDeclaration_extends_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
             null,
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_extends_with() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
-            AstFactory.withClause([AstFactory.typeName4("M", [])]),
-            null,
-            []));
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            null));
   }
 
   void test_visitClassDeclaration_extends_with_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
-            AstFactory.withClause([AstFactory.typeName4("M", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
             null,
             null,
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_multipleMember() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             null,
             null,
             null,
@@ skipping 10 matching lines @@
   }
 
   void test_visitClassDeclaration_parameters() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
             null,
             null,
-            null,
-            []));
+            null));
   }
 
   void test_visitClassDeclaration_parameters_extends() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
             null,
-            null,
-            []));
+            null));
   }
 
   void test_visitClassDeclaration_parameters_extends_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
             null,
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_parameters_extends_with() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
-            AstFactory.withClause([AstFactory.typeName4("M", [])]),
-            null,
-            []));
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            null));
   }
 
   void test_visitClassDeclaration_parameters_extends_with_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
-            AstFactory.extendsClause(AstFactory.typeName4("A", [])),
-            AstFactory.withClause([AstFactory.typeName4("M", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.extendsClause(AstFactory.typeName4("A")),
+            AstFactory.withClause([AstFactory.typeName4("M")]),
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_parameters_implements() {
     _assertClone(
         AstFactory.classDeclaration(
             null,
             "C",
             AstFactory.typeParameterList(["E"]),
             null,
             null,
-            AstFactory.implementsClause([AstFactory.typeName4("B", [])]),
-            []));
+            AstFactory.implementsClause([AstFactory.typeName4("B")])));
   }
 
   void test_visitClassDeclaration_singleMember() {
     _assertClone(
         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, []);
+        AstFactory.classDeclaration(null, "C", null, null, null, null);
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitClassTypeAlias_abstract() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             null,
             Keyword.ABSTRACT,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
             null));
   }
 
   void test_visitClassTypeAlias_abstract_implements() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             null,
             Keyword.ABSTRACT,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("I", [])])));
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_generic() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             AstFactory.typeParameterList(["E"]),
             null,
-            AstFactory.typeName4("S", [AstFactory.typeName4("E", [])]),
+            AstFactory.typeName4("S", [AstFactory.typeName4("E")]),
             AstFactory.withClause(
-                [AstFactory.typeName4("M1", [AstFactory.typeName4("E", [])])]),
+                [AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]),
             null));
   }
 
   void test_visitClassTypeAlias_implements() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             null,
             null,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("I", [])])));
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_minimal() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             null,
             null,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
             null));
   }
 
   void test_visitClassTypeAlias_parameters_abstract() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             AstFactory.typeParameterList(["E"]),
             Keyword.ABSTRACT,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
             null));
   }
 
   void test_visitClassTypeAlias_parameters_abstract_implements() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             AstFactory.typeParameterList(["E"]),
             Keyword.ABSTRACT,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("I", [])])));
+            AstFactory.typeName4("S"),
+            AstFactory.withClause([AstFactory.typeName4("M1")]),
+            AstFactory.implementsClause([AstFactory.typeName4("I")])));
   }
 
   void test_visitClassTypeAlias_parameters_implements() {
     _assertClone(
         AstFactory.classTypeAlias(
             "C",
             AstFactory.typeParameterList(["E"]),
             null,
-            AstFactory.typeName4("S", []),
-            AstFactory.withClause([AstFactory.typeName4("M1", [])]),
-            AstFactory.implementsClause([AstFactory.typeName4("I", [])])));
+            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", [])]),
+        AstFactory.typeName4("S"),
+        AstFactory.withClause([AstFactory.typeName4("M1")]),
         null);
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitComment() {
     _assertClone(
         Comment.createBlockComment(
             <Token>[TokenFactory.tokenFromString("/* comment */")]));
   }
 
   void test_visitCommentReference() {
@@ skipping 10 matching lines @@
   }
 
   void test_visitCompilationUnit_directive() {
     _assertClone(
         AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_directive_declaration() {
     _assertClone(
         AstFactory.compilationUnit4(
-            AstFactory.list([AstFactory.libraryDirective2("l")]),
-            AstFactory.list(
-                [
-                    AstFactory.topLevelVariableDeclaration2(
-                        Keyword.VAR,
-                        [AstFactory.variableDeclaration("a")])])));
+            [AstFactory.libraryDirective2("l")],
+            [AstFactory.topLevelVariableDeclaration2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitCompilationUnit_empty() {
     _assertClone(AstFactory.compilationUnit());
   }
 
   void test_visitCompilationUnit_script() {
     _assertClone(AstFactory.compilationUnit5("!#/bin/dartvm"));
   }
 
@@ skipping 11 matching lines @@
     _assertClone(
         AstFactory.compilationUnit7(
             "!#/bin/dartvm",
             [AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_script_directives_declarations() {
     _assertClone(
         AstFactory.compilationUnit8(
             "!#/bin/dartvm",
-            AstFactory.list([AstFactory.libraryDirective2("l")]),
-            AstFactory.list(
-                [
-                    AstFactory.topLevelVariableDeclaration2(
-                        Keyword.VAR,
-                        [AstFactory.variableDeclaration("a")])])));
+            [AstFactory.libraryDirective2("l")],
+            [AstFactory.topLevelVariableDeclaration2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitConditionalExpression() {
     _assertClone(
         AstFactory.conditionalExpression(
             AstFactory.identifier3("a"),
             AstFactory.identifier3("b"),
             AstFactory.identifier3("c")));
   }
 
   void test_visitConstructorDeclaration_const() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             Keyword.CONST,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_external() {
     _assertClone(
         AstFactory.constructorDeclaration(
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_multipleInitializers() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([]),
-            AstFactory.list(
-                [
-                    AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
-                    AstFactory.constructorFieldInitializer(
-                        false,
-                        "c",
-                        AstFactory.identifier3("d"))]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            [AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
+            AstFactory.constructorFieldInitializer(
+                false,
+                "c",
+                AstFactory.identifier3("d"))],
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_multipleParameters() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList(
-                [
-                    AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
-                    AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
+            AstFactory.formalParameterList([
+                AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+                AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_named() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             "m",
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_singleInitializer() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([]),
-            AstFactory.list(
-                [
-                    AstFactory.constructorFieldInitializer(
-                        false,
-                        "a",
-                        AstFactory.identifier3("b"))]),
-            AstFactory.blockFunctionBody2([])));
+            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.formalParameterList(),
         null,
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.blockFunctionBody2());
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitConstructorFieldInitializer_withThis() {
     _assertClone(
         AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
   }
 
   void test_visitConstructorFieldInitializer_withoutThis() {
     _assertClone(
         AstFactory.constructorFieldInitializer(
             false,
             "a",
             AstFactory.identifier3("b")));
   }
 
   void test_visitConstructorName_named_prefix() {
     _assertClone(
-        AstFactory.constructorName(AstFactory.typeName4("p.C.n", []), null));
+        AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null));
   }
 
   void test_visitConstructorName_unnamed_noPrefix() {
     _assertClone(
-        AstFactory.constructorName(AstFactory.typeName4("C", []), null));
+        AstFactory.constructorName(AstFactory.typeName4("C"), null));
   }
 
   void test_visitConstructorName_unnamed_prefix() {
     _assertClone(
         AstFactory.constructorName(
-            AstFactory.typeName3(AstFactory.identifier5("p", "C"), []),
+            AstFactory.typeName3(AstFactory.identifier5("p", "C")),
             null));
   }
 
   void test_visitContinueStatement_label() {
     _assertClone(AstFactory.continueStatement("l"));
   }
 
   void test_visitContinueStatement_noLabel() {
     _assertClone(AstFactory.continueStatement());
   }
@@ skipping 19 matching lines @@
 
   void test_visitDefaultFormalParameter_positional_value() {
     _assertClone(
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter3("p"),
             AstFactory.integer(0)));
   }
 
   void test_visitDoStatement() {
     _assertClone(
-        AstFactory.doStatement(AstFactory.block([]), AstFactory.identifier3("c")));
+        AstFactory.doStatement(AstFactory.block(), AstFactory.identifier3("c")));
   }
 
   void test_visitDoubleLiteral() {
     _assertClone(AstFactory.doubleLiteral(4.2));
   }
 
   void test_visitEmptyFunctionBody() {
     _assertClone(AstFactory.emptyFunctionBody());
   }
 
@@ skipping 11 matching lines @@
   void test_visitExportDirective_combinators() {
     _assertClone(
         AstFactory.exportDirective2(
             "a.dart",
             [
                 AstFactory.showCombinator([AstFactory.identifier3("A")]),
                 AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitExportDirective_minimal() {
-    _assertClone(AstFactory.exportDirective2("a.dart", []));
+    _assertClone(AstFactory.exportDirective2("a.dart"));
   }
 
   void test_visitExportDirective_withMetadata() {
-    ExportDirective directive = AstFactory.exportDirective2("a.dart", []);
+    ExportDirective directive = AstFactory.exportDirective2("a.dart");
     directive.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(directive);
   }
 
   void test_visitExpressionFunctionBody() {
     _assertClone(
         AstFactory.expressionFunctionBody(AstFactory.identifier3("a")));
   }
 
   void test_visitExpressionStatement() {
     _assertClone(AstFactory.expressionStatement(AstFactory.identifier3("a")));
   }
 
   void test_visitExtendsClause() {
-    _assertClone(AstFactory.extendsClause(AstFactory.typeName4("C", [])));
+    _assertClone(AstFactory.extendsClause(AstFactory.typeName4("C")));
   }
 
   void test_visitFieldDeclaration_instance() {
     _assertClone(
         AstFactory.fieldDeclaration2(
             false,
             Keyword.VAR,
             [AstFactory.variableDeclaration("a")]));
   }
 
   void test_visitFieldDeclaration_static() {
     _assertClone(
         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.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitFieldFormalParameter_functionTyped() {
     _assertClone(
         AstFactory.fieldFormalParameter(
             null,
-            AstFactory.typeName4("A", []),
+            AstFactory.typeName4("A"),
             "a",
             AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
   }
 
   void test_visitFieldFormalParameter_keyword() {
     _assertClone(AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
   }
 
   void test_visitFieldFormalParameter_keywordAndType() {
     _assertClone(
         AstFactory.fieldFormalParameter(
             Keyword.FINAL,
-            AstFactory.typeName4("A", []),
+            AstFactory.typeName4("A"),
             "a"));
   }
 
   void test_visitFieldFormalParameter_type() {
     _assertClone(
-        AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A", []), "a"));
+        AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitForEachStatement_declared() {
     _assertClone(
         AstFactory.forEachStatement(
             AstFactory.declaredIdentifier3("a"),
             AstFactory.identifier3("b"),
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForEachStatement_variable() {
     _assertClone(
         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([])));
+            AstFactory.block()));
   }
 
   void test_visitForEachStatement_variable_await() {
     _assertClone(
         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([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_c() {
     _assertClone(
         AstFactory.forStatement(
             null,
             AstFactory.identifier3("c"),
             null,
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_cu() {
     _assertClone(
         AstFactory.forStatement(
             null,
             AstFactory.identifier3("c"),
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_e() {
     _assertClone(
         AstFactory.forStatement(
             AstFactory.identifier3("e"),
             null,
             null,
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ec() {
     _assertClone(
         AstFactory.forStatement(
             AstFactory.identifier3("e"),
             AstFactory.identifier3("c"),
             null,
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ecu() {
     _assertClone(
         AstFactory.forStatement(
             AstFactory.identifier3("e"),
             AstFactory.identifier3("c"),
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_eu() {
     _assertClone(
         AstFactory.forStatement(
             AstFactory.identifier3("e"),
             null,
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_i() {
     _assertClone(
         AstFactory.forStatement2(
             AstFactory.variableDeclarationList2(
                 Keyword.VAR,
                 [AstFactory.variableDeclaration("i")]),
             null,
             null,
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_ic() {
     _assertClone(
         AstFactory.forStatement2(
             AstFactory.variableDeclarationList2(
                 Keyword.VAR,
                 [AstFactory.variableDeclaration("i")]),
             AstFactory.identifier3("c"),
             null,
-            AstFactory.block([])));
+            AstFactory.block()));
   }
 
   void test_visitForStatement_icu() {
     _assertClone(
         AstFactory.forStatement2(
             AstFactory.variableDeclarationList2(
                 Keyword.VAR,
                 [AstFactory.variableDeclaration("i")]),
             AstFactory.identifier3("c"),
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_iu() {
     _assertClone(
         AstFactory.forStatement2(
             AstFactory.variableDeclarationList2(
                 Keyword.VAR,
                 [AstFactory.variableDeclaration("i")]),
             null,
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitForStatement_u() {
     _assertClone(
         AstFactory.forStatement(
             null,
             null,
-            AstFactory.list([AstFactory.identifier3("u")]),
-            AstFactory.block([])));
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitFormalParameterList_empty() {
-    _assertClone(AstFactory.formalParameterList([]));
+    _assertClone(AstFactory.formalParameterList());
   }
 
   void test_visitFormalParameterList_n() {
     _assertClone(
         AstFactory.formalParameterList(
             [
                 AstFactory.namedFormalParameter(
                     AstFactory.simpleFormalParameter3("a"),
                     AstFactory.integer(0))]));
   }
@@ skipping 176 matching lines @@
             AstFactory.functionExpression()));
   }
 
   void test_visitFunctionDeclaration_withMetadata() {
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         null,
         "f",
         AstFactory.functionExpression());
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitFunctionExpression() {
     _assertClone(AstFactory.functionExpression());
   }
 
   void test_visitFunctionExpressionInvocation() {
     _assertClone(
-        AstFactory.functionExpressionInvocation(AstFactory.identifier3("f"), []));
+        AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
   }
 
   void test_visitFunctionTypeAlias_generic() {
     _assertClone(
         AstFactory.typeAlias(
-            AstFactory.typeName4("A", []),
+            AstFactory.typeName4("A"),
             "F",
             AstFactory.typeParameterList(["B"]),
-            AstFactory.formalParameterList([])));
+            AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_nonGeneric() {
     _assertClone(
         AstFactory.typeAlias(
-            AstFactory.typeName4("A", []),
+            AstFactory.typeName4("A"),
             "F",
             null,
-            AstFactory.formalParameterList([])));
+            AstFactory.formalParameterList()));
   }
 
   void test_visitFunctionTypeAlias_withMetadata() {
     FunctionTypeAlias declaration = AstFactory.typeAlias(
-        AstFactory.typeName4("A", []),
+        AstFactory.typeName4("A"),
         "F",
         null,
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitFunctionTypedFormalParameter_noType() {
-    _assertClone(AstFactory.functionTypedFormalParameter(null, "f", []));
+    _assertClone(AstFactory.functionTypedFormalParameter(null, "f"));
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
     _assertClone(
         AstFactory.functionTypedFormalParameter(
-            AstFactory.typeName4("T", []),
-            "f",
-            []));
+            AstFactory.typeName4("T"),
+            "f"));
   }
 
   void test_visitIfStatement_withElse() {
     _assertClone(
         AstFactory.ifStatement2(
             AstFactory.identifier3("c"),
-            AstFactory.block([]),
-            AstFactory.block([])));
+            AstFactory.block(),
+            AstFactory.block()));
   }
 
   void test_visitIfStatement_withoutElse() {
     _assertClone(
-        AstFactory.ifStatement(AstFactory.identifier3("c"), AstFactory.block([])));
+        AstFactory.ifStatement(AstFactory.identifier3("c"), AstFactory.block()));
   }
 
   void test_visitImplementsClause_multiple() {
     _assertClone(
         AstFactory.implementsClause(
-            [AstFactory.typeName4("A", []), AstFactory.typeName4("B", [])]));
+            [AstFactory.typeName4("A"), AstFactory.typeName4("B")]));
   }
 
   void test_visitImplementsClause_single() {
-    _assertClone(AstFactory.implementsClause([AstFactory.typeName4("A", [])]));
+    _assertClone(AstFactory.implementsClause([AstFactory.typeName4("A")]));
   }
 
   void test_visitImportDirective_combinator() {
     _assertClone(
         AstFactory.importDirective3(
             "a.dart",
             null,
             [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_combinators() {
     _assertClone(
         AstFactory.importDirective3(
             "a.dart",
             null,
             [
                 AstFactory.showCombinator([AstFactory.identifier3("A")]),
                 AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
   }
 
   void test_visitImportDirective_minimal() {
-    _assertClone(AstFactory.importDirective3("a.dart", null, []));
+    _assertClone(AstFactory.importDirective3("a.dart", null));
   }
 
   void test_visitImportDirective_prefix() {
-    _assertClone(AstFactory.importDirective3("a.dart", "p", []));
+    _assertClone(AstFactory.importDirective3("a.dart", "p"));
   }
 
   void test_visitImportDirective_prefix_combinator() {
     _assertClone(
         AstFactory.importDirective3(
             "a.dart",
             "p",
             [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
   }
 
   void test_visitImportDirective_prefix_combinators() {
     _assertClone(
         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, []);
+    ImportDirective directive = AstFactory.importDirective3("a.dart", null);
     directive.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(directive);
   }
 
   void test_visitImportHideCombinator_multiple() {
     _assertClone(
         AstFactory.hideCombinator(
             [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
   }
 
   void test_visitImportHideCombinator_single() {
@@ skipping 14 matching lines @@
     _assertClone(
         AstFactory.indexExpression(
             AstFactory.identifier3("a"),
             AstFactory.identifier3("i")));
   }
 
   void test_visitInstanceCreationExpression_const() {
     _assertClone(
         AstFactory.instanceCreationExpression2(
             Keyword.CONST,
-            AstFactory.typeName4("C", []),
-            []));
+            AstFactory.typeName4("C")));
   }
 
   void test_visitInstanceCreationExpression_named() {
     _assertClone(
         AstFactory.instanceCreationExpression3(
             Keyword.NEW,
-            AstFactory.typeName4("C", []),
-            "c",
-            []));
+            AstFactory.typeName4("C"),
+            "c"));
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
     _assertClone(
         AstFactory.instanceCreationExpression2(
             Keyword.NEW,
-            AstFactory.typeName4("C", []),
-            []));
+            AstFactory.typeName4("C")));
   }
 
   void test_visitIntegerLiteral() {
     _assertClone(AstFactory.integer(42));
   }
 
   void test_visitInterpolationExpression_expression() {
     _assertClone(
         AstFactory.interpolationExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitInterpolationExpression_identifier() {
     _assertClone(AstFactory.interpolationExpression2("a"));
   }
 
   void test_visitInterpolationString() {
     _assertClone(AstFactory.interpolationString("'x", "x"));
   }
 
   void test_visitIsExpression_negated() {
     _assertClone(
         AstFactory.isExpression(
             AstFactory.identifier3("a"),
             true,
-            AstFactory.typeName4("C", [])));
+            AstFactory.typeName4("C")));
   }
 
   void test_visitIsExpression_normal() {
     _assertClone(
         AstFactory.isExpression(
             AstFactory.identifier3("a"),
             false,
-            AstFactory.typeName4("C", [])));
+            AstFactory.typeName4("C")));
   }
 
   void test_visitLabel() {
     _assertClone(AstFactory.label2("a"));
   }
 
   void test_visitLabeledStatement_multiple() {
     _assertClone(
         AstFactory.labeledStatement(
-            AstFactory.list([AstFactory.label2("a"), AstFactory.label2("b")]),
+            [AstFactory.label2("a"), AstFactory.label2("b")],
             AstFactory.returnStatement()));
   }
 
   void test_visitLabeledStatement_single() {
     _assertClone(
         AstFactory.labeledStatement(
-            AstFactory.list([AstFactory.label2("a")]),
+            [AstFactory.label2("a")],
             AstFactory.returnStatement()));
   }
 
   void test_visitLibraryDirective() {
     _assertClone(AstFactory.libraryDirective2("l"));
   }
 
   void test_visitLibraryDirective_withMetadata() {
     LibraryDirective directive = AstFactory.libraryDirective2("l");
     directive.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(directive);
   }
 
   void test_visitLibraryIdentifier_multiple() {
     _assertClone(
         AstFactory.libraryIdentifier(
             [
                 AstFactory.identifier3("a"),
                 AstFactory.identifier3("b"),
                 AstFactory.identifier3("c")]));
   }
 
   void test_visitLibraryIdentifier_single() {
     _assertClone(AstFactory.libraryIdentifier([AstFactory.identifier3("a")]));
   }
 
   void test_visitListLiteral_const() {
-    _assertClone(AstFactory.listLiteral2(Keyword.CONST, null, []));
+    _assertClone(AstFactory.listLiteral2(Keyword.CONST, null));
   }
 
   void test_visitListLiteral_empty() {
-    _assertClone(AstFactory.listLiteral([]));
+    _assertClone(AstFactory.listLiteral());
   }
 
   void test_visitListLiteral_nonEmpty() {
     _assertClone(
         AstFactory.listLiteral(
             [
                 AstFactory.identifier3("a"),
                 AstFactory.identifier3("b"),
                 AstFactory.identifier3("c")]));
   }
 
   void test_visitMapLiteralEntry() {
     _assertClone(AstFactory.mapLiteralEntry("a", AstFactory.identifier3("b")));
   }
 
   void test_visitMapLiteral_const() {
-    _assertClone(AstFactory.mapLiteral(Keyword.CONST, null, []));
+    _assertClone(AstFactory.mapLiteral(Keyword.CONST, null));
   }
 
   void test_visitMapLiteral_empty() {
-    _assertClone(AstFactory.mapLiteral2([]));
+    _assertClone(AstFactory.mapLiteral2());
   }
 
   void test_visitMapLiteral_nonEmpty() {
     _assertClone(
         AstFactory.mapLiteral2(
             [
                 AstFactory.mapLiteralEntry("a", AstFactory.identifier3("a")),
                 AstFactory.mapLiteralEntry("b", AstFactory.identifier3("b")),
                 AstFactory.mapLiteralEntry("c", AstFactory.identifier3("c"))]));
   }
 
   void test_visitMethodDeclaration_external() {
     _assertClone(
         AstFactory.methodDeclaration(
             null,
             null,
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([])));
+            AstFactory.formalParameterList()));
   }
 
   void test_visitMethodDeclaration_external_returnType() {
     _assertClone(
         AstFactory.methodDeclaration(
             null,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([])));
+            AstFactory.formalParameterList()));
   }
 
   void test_visitMethodDeclaration_getter() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
             null,
             Keyword.GET,
             null,
             AstFactory.identifier3("m"),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_getter_returnType() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             Keyword.GET,
             null,
             AstFactory.identifier3("m"),
             null,
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_getter_seturnType() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             Keyword.SET,
             null,
             AstFactory.identifier3("m"),
             AstFactory.formalParameterList(
                 [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_minimal() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
             null,
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_multipleParameters() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
             null,
             null,
             null,
             AstFactory.identifier3("m"),
             AstFactory.formalParameterList(
                 [
                     AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
                     AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_operator() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
             null,
             null,
             Keyword.OPERATOR,
             AstFactory.identifier3("+"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_operator_returnType() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             null,
             Keyword.OPERATOR,
             AstFactory.identifier3("+"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_returnType() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_setter() {
     _assertClone(
         AstFactory.methodDeclaration2(
             null,
             null,
             Keyword.SET,
             null,
             AstFactory.identifier3("m"),
             AstFactory.formalParameterList(
                 [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_static() {
     _assertClone(
         AstFactory.methodDeclaration2(
             Keyword.STATIC,
             null,
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_static_returnType() {
     _assertClone(
         AstFactory.methodDeclaration2(
             Keyword.STATIC,
-            AstFactory.typeName4("T", []),
+            AstFactory.typeName4("T"),
             null,
             null,
             AstFactory.identifier3("m"),
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
   }
 
   void test_visitMethodDeclaration_withMetadata() {
     MethodDeclaration declaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3("m"),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitMethodInvocation_noTarget() {
-    _assertClone(AstFactory.methodInvocation2("m", []));
+    _assertClone(AstFactory.methodInvocation2("m"));
   }
 
   void test_visitMethodInvocation_target() {
     _assertClone(
-        AstFactory.methodInvocation(AstFactory.identifier3("t"), "m", []));
+        AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
   }
 
   void test_visitNamedExpression() {
     _assertClone(AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitNamedFormalParameter() {
     _assertClone(
         AstFactory.namedFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
@@ skipping 17 matching lines @@
         AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
   }
 
   void test_visitPartDirective() {
     _assertClone(AstFactory.partDirective2("a.dart"));
   }
 
   void test_visitPartDirective_withMetadata() {
     PartDirective directive = AstFactory.partDirective2("a.dart");
     directive.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(directive);
   }
 
   void test_visitPartOfDirective() {
     _assertClone(
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])));
   }
 
   void test_visitPartOfDirective_withMetadata() {
     PartOfDirective directive =
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
     directive.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(directive);
   }
 
   void test_visitPositionalFormalParameter() {
     _assertClone(
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
             AstFactory.integer(0)));
   }
 
   void test_visitPostfixExpression() {
     _assertClone(
         AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
   }
 
   void test_visitPrefixExpression() {
     _assertClone(
         AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
   }
 
   void test_visitPrefixedIdentifier() {
     _assertClone(AstFactory.identifier5("a", "b"));
   }
 
   void test_visitPropertyAccess() {
     _assertClone(AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b"));
   }
 
   void test_visitRedirectingConstructorInvocation_named() {
-    _assertClone(AstFactory.redirectingConstructorInvocation2("c", []));
+    _assertClone(AstFactory.redirectingConstructorInvocation2("c"));
   }
 
   void test_visitRedirectingConstructorInvocation_unnamed() {
-    _assertClone(AstFactory.redirectingConstructorInvocation([]));
+    _assertClone(AstFactory.redirectingConstructorInvocation());
   }
 
   void test_visitRethrowExpression() {
     _assertClone(AstFactory.rethrowExpression());
   }
 
   void test_visitReturnStatement_expression() {
     _assertClone(AstFactory.returnStatement2(AstFactory.identifier3("a")));
   }
 
   void test_visitReturnStatement_noExpression() {
     _assertClone(AstFactory.returnStatement());
   }
 
   void test_visitScriptTag() {
     String scriptTag = "!#/bin/dart.exe";
     _assertClone(AstFactory.scriptTag(scriptTag));
   }
 
   void test_visitSimpleFormalParameter_keyword() {
     _assertClone(AstFactory.simpleFormalParameter(Keyword.VAR, "a"));
   }
 
   void test_visitSimpleFormalParameter_keyword_type() {
     _assertClone(
         AstFactory.simpleFormalParameter2(
             Keyword.FINAL,
-            AstFactory.typeName4("A", []),
+            AstFactory.typeName4("A"),
             "a"));
   }
 
   void test_visitSimpleFormalParameter_type() {
     _assertClone(
-        AstFactory.simpleFormalParameter4(AstFactory.typeName4("A", []), "a"));
+        AstFactory.simpleFormalParameter4(AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitSimpleIdentifier() {
     _assertClone(AstFactory.identifier3("a"));
   }
 
   void test_visitSimpleStringLiteral() {
     _assertClone(AstFactory.string2("a"));
   }
 
   void test_visitStringInterpolation() {
     _assertClone(
         AstFactory.string(
             [
                 AstFactory.interpolationString("'a", "a"),
                 AstFactory.interpolationExpression(AstFactory.identifier3("e")),
                 AstFactory.interpolationString("b'", "b")]));
   }
 
   void test_visitSuperConstructorInvocation() {
-    _assertClone(AstFactory.superConstructorInvocation([]));
+    _assertClone(AstFactory.superConstructorInvocation());
   }
 
   void test_visitSuperConstructorInvocation_named() {
-    _assertClone(AstFactory.superConstructorInvocation2("c", []));
+    _assertClone(AstFactory.superConstructorInvocation2("c"));
   }
 
   void test_visitSuperExpression() {
     _assertClone(AstFactory.superExpression());
   }
 
   void test_visitSwitchCase_multipleLabels() {
     _assertClone(
         AstFactory.switchCase2(
-            AstFactory.list([AstFactory.label2("l1"), AstFactory.label2("l2")]),
+            [AstFactory.label2("l1"), AstFactory.label2("l2")],
             AstFactory.identifier3("a"),
-            [AstFactory.block([])]));
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_multipleStatements() {
     _assertClone(
         AstFactory.switchCase(
             AstFactory.identifier3("a"),
-            [AstFactory.block([]), AstFactory.block([])]));
+            [AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchCase_noLabels() {
     _assertClone(
-        AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block([])]));
+        AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
   }
 
   void test_visitSwitchCase_singleLabel() {
     _assertClone(
         AstFactory.switchCase2(
-            AstFactory.list([AstFactory.label2("l1")]),
+            [AstFactory.label2("l1")],
             AstFactory.identifier3("a"),
-            [AstFactory.block([])]));
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleLabels() {
     _assertClone(
         AstFactory.switchDefault(
-            AstFactory.list([AstFactory.label2("l1"), AstFactory.label2("l2")]),
-            [AstFactory.block([])]));
+            [AstFactory.label2("l1"), AstFactory.label2("l2")],
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_multipleStatements() {
     _assertClone(
-        AstFactory.switchDefault2([AstFactory.block([]), AstFactory.block([])]));
+        AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_noLabels() {
-    _assertClone(AstFactory.switchDefault2([AstFactory.block([])]));
+    _assertClone(AstFactory.switchDefault2([AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_singleLabel() {
     _assertClone(
         AstFactory.switchDefault(
-            AstFactory.list([AstFactory.label2("l1")]),
-            [AstFactory.block([])]));
+            [AstFactory.label2("l1")],
+            [AstFactory.block()]));
   }
 
   void test_visitSwitchStatement() {
     _assertClone(
         AstFactory.switchStatement(
             AstFactory.identifier3("a"),
             [
-                AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block([])]),
-                AstFactory.switchDefault2([AstFactory.block([])])]));
+                AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]),
+                AstFactory.switchDefault2([AstFactory.block()])]));
   }
 
   void test_visitSymbolLiteral_multiple() {
     _assertClone(AstFactory.symbolLiteral(["a", "b", "c"]));
   }
 
   void test_visitSymbolLiteral_single() {
     _assertClone(AstFactory.symbolLiteral(["a"]));
   }
 
@@ skipping 15 matching lines @@
   void test_visitTopLevelVariableDeclaration_single() {
     _assertClone(
         AstFactory.topLevelVariableDeclaration2(
             Keyword.VAR,
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitTryStatement_catch() {
     _assertClone(
         AstFactory.tryStatement2(
-            AstFactory.block([]),
-            [AstFactory.catchClause3(AstFactory.typeName4("E", []), [])]));
+            AstFactory.block(),
+            [AstFactory.catchClause3(AstFactory.typeName4("E"))]));
   }
 
   void test_visitTryStatement_catchFinally() {
     _assertClone(
         AstFactory.tryStatement3(
-            AstFactory.block([]),
-            AstFactory.list([AstFactory.catchClause3(AstFactory.typeName4("E", []), [])]),
-            AstFactory.block([])));
+            AstFactory.block(),
+            [AstFactory.catchClause3(AstFactory.typeName4("E"))],
+            AstFactory.block()));
   }
 
   void test_visitTryStatement_catches() {
     _assertClone(
         AstFactory.tryStatement2(
-            AstFactory.block([]),
+            AstFactory.block(),
             [
-                AstFactory.catchClause3(AstFactory.typeName4("E", []), []),
-                AstFactory.catchClause3(AstFactory.typeName4("F", []), [])]));
+                AstFactory.catchClause3(AstFactory.typeName4("E")),
+                AstFactory.catchClause3(AstFactory.typeName4("F"))]));
   }
 
   void test_visitTryStatement_finally() {
     _assertClone(
-        AstFactory.tryStatement(AstFactory.block([]), AstFactory.block([])));
+        AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
   }
 
   void test_visitTypeArgumentList_multiple() {
     _assertClone(
         AstFactory.typeArgumentList(
-            [AstFactory.typeName4("E", []), AstFactory.typeName4("F", [])]));
+            [AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
   }
 
   void test_visitTypeArgumentList_single() {
-    _assertClone(AstFactory.typeArgumentList([AstFactory.typeName4("E", [])]));
+    _assertClone(AstFactory.typeArgumentList([AstFactory.typeName4("E")]));
   }
 
   void test_visitTypeName_multipleArgs() {
     _assertClone(
         AstFactory.typeName4(
             "C",
-            [AstFactory.typeName4("D", []), AstFactory.typeName4("E", [])]));
+            [AstFactory.typeName4("D"), AstFactory.typeName4("E")]));
   }
 
   void test_visitTypeName_nestedArg() {
     _assertClone(
         AstFactory.typeName4(
             "C",
-            [AstFactory.typeName4("D", [AstFactory.typeName4("E", [])])]));
+            [AstFactory.typeName4("D", [AstFactory.typeName4("E")])]));
   }
 
   void test_visitTypeName_noArgs() {
-    _assertClone(AstFactory.typeName4("C", []));
+    _assertClone(AstFactory.typeName4("C"));
   }
 
   void test_visitTypeName_singleArg() {
-    _assertClone(AstFactory.typeName4("C", [AstFactory.typeName4("D", [])]));
+    _assertClone(AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
   }
 
   void test_visitTypeParameterList_multiple() {
     _assertClone(AstFactory.typeParameterList(["E", "F"]));
   }
 
   void test_visitTypeParameterList_single() {
     _assertClone(AstFactory.typeParameterList(["E"]));
   }
 
   void test_visitTypeParameter_withExtends() {
-    _assertClone(AstFactory.typeParameter2("E", AstFactory.typeName4("C", [])));
+    _assertClone(AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
   }
 
   void test_visitTypeParameter_withMetadata() {
     TypeParameter parameter = AstFactory.typeParameter("E");
     parameter.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(parameter);
   }
 
   void test_visitTypeParameter_withoutExtends() {
     _assertClone(AstFactory.typeParameter("E"));
   }
 
   void test_visitVariableDeclarationList_const_type() {
     _assertClone(
         AstFactory.variableDeclarationList(
             Keyword.CONST,
-            AstFactory.typeName4("C", []),
+            AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_final_noType() {
     _assertClone(
         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.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declarationList);
   }
 
   void test_visitVariableDeclarationList_type() {
     _assertClone(
         AstFactory.variableDeclarationList(
             null,
-            AstFactory.typeName4("C", []),
+            AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_var() {
     _assertClone(
         AstFactory.variableDeclarationList2(
             Keyword.VAR,
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationStatement() {
     _assertClone(
         AstFactory.variableDeclarationStatement(
             null,
-            AstFactory.typeName4("C", []),
+            AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("c")]));
   }
 
   void test_visitVariableDeclaration_initialized() {
     _assertClone(
         AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitVariableDeclaration_uninitialized() {
     _assertClone(AstFactory.variableDeclaration("a"));
   }
 
   void test_visitVariableDeclaration_withMetadata() {
     VariableDeclaration declaration = AstFactory.variableDeclaration("a");
     declaration.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("deprecated"))]);
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitWhileStatement() {
     _assertClone(
-        AstFactory.whileStatement(AstFactory.identifier3("c"), AstFactory.block([])));
+        AstFactory.whileStatement(AstFactory.identifier3("c"), AstFactory.block()));
   }
 
   void test_visitWithClause_multiple() {
     _assertClone(
         AstFactory.withClause(
             [
-                AstFactory.typeName4("A", []),
-                AstFactory.typeName4("B", []),
-                AstFactory.typeName4("C", [])]));
+                AstFactory.typeName4("A"),
+                AstFactory.typeName4("B"),
+                AstFactory.typeName4("C")]));
   }
 
   void test_visitWithClause_single() {
-    _assertClone(AstFactory.withClause([AstFactory.typeName4("A", [])]));
+    _assertClone(AstFactory.withClause([AstFactory.typeName4("A")]));
   }
 
   void test_visitYieldStatement() {
     _assertClone(AstFactory.yieldStatement(AstFactory.identifier3("A")));
   }
 
   /**
    * Assert that an `AstCloner` will produce the expected AST structure when
    * visiting the given [node].
    *
@@ skipping 1542 matching lines @@
     NodeReplacerTest_ListGetter<WithClause, TypeName> {
   ListGetter_NodeReplacerTest_test_withClause(int arg0) : super(arg0);
 
   @override
   NodeList<TypeName> getList(WithClause node) => node.mixinTypes;
 }
 
 class ListUtilitiesTest {
   void test_addAll_emptyToEmpty() {
     List<String> list = new List<String>();
-    List<String> elements = [];
+    List<String> elements = <String>[];
     ListUtilities.addAll(list, elements);
     expect(list.length, 0);
   }
 
   void test_addAll_emptyToNonEmpty() {
     List<String> list = new List<String>();
     list.add("a");
-    List<String> elements = [];
+    List<String> elements = <String>[];
     ListUtilities.addAll(list, elements);
     expect(list.length, 1);
   }
 
   void test_addAll_nonEmptyToEmpty() {
     List<String> list = new List<String>();
     List<String> elements = ["b", "c"];
     ListUtilities.addAll(list, elements);
     expect(list.length, 2);
   }
@@ skipping 118 matching lines @@
     expect(iterator.value, same(newValue));
     expect(iterator.moveNext(), isFalse);
   }
 
   MultipleMapIterator<String, String> _iterator(List<Map> maps) {
     return new MultipleMapIterator<String, String>(maps);
   }
 }
 
 class NodeReplacerTest extends EngineTestCase {
+  /**
+   * An empty list of tokens.
+   */
+  static const List<Token> EMPTY_TOKEN_LIST = const <Token>[];
+
   void test_adjacentStrings() {
     AdjacentStrings node =
         AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_adjacentStrings_2(0));
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_adjacentStrings(1));
   }
@@ skipping 11 matching lines @@
   void test_argumentList() {
     ArgumentList node = AstFactory.argumentList([AstFactory.integer(0)]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_argumentList(0));
   }
 
   void test_asExpression() {
     AsExpression node = AstFactory.asExpression(
         AstFactory.integer(0),
         AstFactory.typeName3(
             AstFactory.identifier3("a"),
-            [AstFactory.typeName4("C", [])]));
+            [AstFactory.typeName4("C")]));
     _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression());
   }
 
   void test_assertStatement() {
     AssertStatement node =
         AstFactory.assertStatement(AstFactory.booleanLiteral(true));
     _assertReplace(node, new Getter_NodeReplacerTest_test_assertStatement());
   }
 
@@ skipping 18 matching lines @@
     _assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression_2());
   }
 
   void test_block() {
     Block node = AstFactory.block([AstFactory.emptyStatement()]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_block(0));
   }
 
   void test_blockFunctionBody() {
-    BlockFunctionBody node = AstFactory.blockFunctionBody(AstFactory.block([]));
+    BlockFunctionBody node = AstFactory.blockFunctionBody(AstFactory.block());
     _assertReplace(node, new Getter_NodeReplacerTest_test_blockFunctionBody());
   }
 
   void test_breakStatement() {
     BreakStatement node = AstFactory.breakStatement2("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_breakStatement());
   }
 
   void test_cascadeExpression() {
     CascadeExpression node = AstFactory.cascadeExpression(
         AstFactory.integer(0),
         [AstFactory.propertyAccess(null, AstFactory.identifier3("b"))]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_cascadeExpression());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_cascadeExpression(0));
   }
 
   void test_catchClause() {
     CatchClause node = AstFactory.catchClause5(
-        AstFactory.typeName4("E", []),
+        AstFactory.typeName4("E"),
         "e",
         "s",
         [AstFactory.emptyStatement()]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_3());
     _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause());
   }
 
   void test_classDeclaration() {
     ClassDeclaration node = AstFactory.classDeclaration(
         null,
         "A",
         AstFactory.typeParameterList(["E"]),
-        AstFactory.extendsClause(AstFactory.typeName4("B", [])),
-        AstFactory.withClause([AstFactory.typeName4("C", [])]),
-        AstFactory.implementsClause([AstFactory.typeName4("D", [])]),
+        AstFactory.extendsClause(AstFactory.typeName4("B")),
+        AstFactory.withClause([AstFactory.typeName4("C")]),
+        AstFactory.implementsClause([AstFactory.typeName4("D")]),
         [
             AstFactory.fieldDeclaration2(
                 false,
                 null,
                 [AstFactory.variableDeclaration("f")])]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     node.nativeClause = AstFactory.nativeClause("");
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_6());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_3());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_classDeclaration(0));
     _testAnnotatedNode(node);
   }
 
   void test_classTypeAlias() {
     ClassTypeAlias node = AstFactory.classTypeAlias(
         "A",
         AstFactory.typeParameterList(["E"]),
         null,
-        AstFactory.typeName4("B", []),
-        AstFactory.withClause([AstFactory.typeName4("C", [])]),
-        AstFactory.implementsClause([AstFactory.typeName4("D", [])]));
+        AstFactory.typeName4("B"),
+        AstFactory.withClause([AstFactory.typeName4("C")]),
+        AstFactory.implementsClause([AstFactory.typeName4("D")]));
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_5());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_3());
     _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_2());
     _testAnnotatedNode(node);
   }
 
   void test_comment() {
-    Comment node = Comment.createEndOfLineComment(new List<Token>(0));
+    Comment node = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.references.add(
         new CommentReference(null, AstFactory.identifier3("x")));
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_comment(0));
   }
 
   void test_commentReference() {
     CommentReference node =
         new CommentReference(null, AstFactory.identifier3("x"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_commentReference());
   }
 
   void test_compilationUnit() {
     CompilationUnit node = AstFactory.compilationUnit8(
         "",
-        AstFactory.list([AstFactory.libraryDirective2("lib")]),
-        AstFactory.list(
-            [
-                AstFactory.topLevelVariableDeclaration2(
-                    null,
-                    [AstFactory.variableDeclaration("X")])]));
+        [AstFactory.libraryDirective2("lib")],
+        [AstFactory.topLevelVariableDeclaration2(
+            null,
+            [AstFactory.variableDeclaration("X")])]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_compilationUnit());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_compilationUnit(0));
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_compilationUnit_2(0));
   }
 
   void test_conditionalExpression() {
@@ skipping 11 matching lines @@
         node,
         new Getter_NodeReplacerTest_test_conditionalExpression());
   }
 
   void test_constructorDeclaration() {
     ConstructorDeclaration node = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         "d",
-        AstFactory.formalParameterList([]),
-        AstFactory.list(
-            [AstFactory.constructorFieldInitializer(false, "x", AstFactory.integer(0))]),
+        AstFactory.formalParameterList(),
+        [AstFactory.constructorFieldInitializer(false, "x", AstFactory.integer(0))],
         AstFactory.emptyFunctionBody());
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        [AstFactory.annotation(AstFactory.identifier3("a"))];
     node.redirectedConstructor =
-        AstFactory.constructorName(AstFactory.typeName4("B", []), "a");
+        AstFactory.constructorName(AstFactory.typeName4("B"), "a");
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_4());
     _assertReplace(
@@ skipping 14 matching lines @@
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorFieldInitializer());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorFieldInitializer_2());
   }
 
   void test_constructorName() {
     ConstructorName node =
-        AstFactory.constructorName(AstFactory.typeName4("C", []), "n");
+        AstFactory.constructorName(AstFactory.typeName4("C"), "n");
     _assertReplace(node, new Getter_NodeReplacerTest_test_constructorName());
     _assertReplace(node, new Getter_NodeReplacerTest_test_constructorName_2());
   }
 
   void test_continueStatement() {
     ContinueStatement node = AstFactory.continueStatement("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_continueStatement());
   }
 
   void test_declaredIdentifier() {
     DeclaredIdentifier node =
-        AstFactory.declaredIdentifier4(AstFactory.typeName4("C", []), "i");
+        AstFactory.declaredIdentifier4(AstFactory.typeName4("C"), "i");
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_declaredIdentifier_2());
     _testAnnotatedNode(node);
   }
 
   void test_defaultFormalParameter() {
     DefaultFormalParameter node = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p"),
         AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_defaultFormalParameter());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_defaultFormalParameter_2());
   }
 
   void test_doStatement() {
     DoStatement node =
-        AstFactory.doStatement(AstFactory.block([]), AstFactory.booleanLiteral(true));
+        AstFactory.doStatement(AstFactory.block(), AstFactory.booleanLiteral(true));
     _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement());
   }
 
   void test_enumConstantDeclaration() {
     EnumConstantDeclaration node = new EnumConstantDeclaration(
-        Comment.createEndOfLineComment(new List<Token>(0)),
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]),
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST),
+        [AstFactory.annotation(AstFactory.identifier3("a"))],
         AstFactory.identifier3("C"));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_enumConstantDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_enumDeclaration() {
     EnumDeclaration node = AstFactory.enumDeclaration2("E", ["ONE", "TWO"]);
-    node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+    node.documentationComment
+        = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_enumDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_exportDirective() {
     ExportDirective node =
         AstFactory.exportDirective2("", [AstFactory.hideCombinator2(["C"])]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _testNamespaceDirective(node);
   }
 
   void test_expressionFunctionBody() {
     ExpressionFunctionBody node =
         AstFactory.expressionFunctionBody(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_expressionFunctionBody());
   }
 
   void test_expressionStatement() {
     ExpressionStatement node =
         AstFactory.expressionStatement(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_expressionStatement());
   }
 
   void test_extendsClause() {
     ExtendsClause node =
-        AstFactory.extendsClause(AstFactory.typeName4("S", []));
+        AstFactory.extendsClause(AstFactory.typeName4("S"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_extendsClause());
   }
 
   void test_fieldDeclaration() {
     FieldDeclaration node = AstFactory.fieldDeclaration(
         false,
         null,
-        AstFactory.typeName4("C", []),
+        AstFactory.typeName4("C"),
         [AstFactory.variableDeclaration("c")]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_fieldDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_fieldFormalParameter() {
     FieldFormalParameter node = AstFactory.fieldFormalParameter(
         null,
-        AstFactory.typeName4("C", []),
+        AstFactory.typeName4("C"),
         "f",
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_fieldFormalParameter_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_fieldFormalParameter());
     _testNormalFormalParameter(node);
   }
 
   void test_forEachStatement_withIdentifier() {
     ForEachStatement node = AstFactory.forEachStatement2(
         AstFactory.identifier3("i"),
         AstFactory.identifier3("l"),
-        AstFactory.block([]));
+        AstFactory.block());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier());
   }
 
   void test_forEachStatement_withLoopVariable() {
     ForEachStatement node = AstFactory.forEachStatement(
         AstFactory.declaredIdentifier3("e"),
         AstFactory.identifier3("l"),
-        AstFactory.block([]));
+        AstFactory.block());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3());
   }
 
   void test_forStatement_withInitialization() {
     ForStatement node = AstFactory.forStatement(
         AstFactory.identifier3("a"),
         AstFactory.booleanLiteral(true),
-        AstFactory.list([AstFactory.integer(0)]),
-        AstFactory.block([]));
+        [AstFactory.integer(0)],
+        AstFactory.block());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withInitialization_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withInitialization_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withInitialization());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_forStatement_withInitialization(0));
   }
 
   void test_forStatement_withVariables() {
     ForStatement node = AstFactory.forStatement2(
         AstFactory.variableDeclarationList2(
             null,
             [AstFactory.variableDeclaration("i")]),
         AstFactory.booleanLiteral(true),
-        AstFactory.list([AstFactory.integer(0)]),
-        AstFactory.block([]));
+        [AstFactory.integer(0)],
+        AstFactory.block());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withVariables_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withVariables_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withVariables());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_forStatement_withVariables(0));
   }
 
   void test_formalParameterList() {
     FormalParameterList node =
         AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("p")]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_formalParameterList(0));
   }
 
   void test_functionDeclaration() {
     FunctionDeclaration node = AstFactory.functionDeclaration(
-        AstFactory.typeName4("R", []),
+        AstFactory.typeName4("R"),
         null,
         "f",
         AstFactory.functionExpression2(
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody(AstFactory.block([]))));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody(AstFactory.block())));
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclaration_2());
     _testAnnotatedNode(node);
   }
 
   void test_functionDeclarationStatement() {
     FunctionDeclarationStatement node = AstFactory.functionDeclarationStatement(
-        AstFactory.typeName4("R", []),
+        AstFactory.typeName4("R"),
         null,
         "f",
         AstFactory.functionExpression2(
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody(AstFactory.block([]))));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody(AstFactory.block())));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionDeclarationStatement());
   }
 
   void test_functionExpression() {
     FunctionExpression node = AstFactory.functionExpression2(
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody(AstFactory.block([])));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody(AstFactory.block()));
     _assertReplace(node, new Getter_NodeReplacerTest_test_functionExpression());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionExpression_2());
   }
 
   void test_functionExpressionInvocation() {
     FunctionExpressionInvocation node = AstFactory.functionExpressionInvocation(
         AstFactory.identifier3("f"),
         [AstFactory.integer(0)]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionExpressionInvocation());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionExpressionInvocation_2());
   }
 
   void test_functionTypeAlias() {
     FunctionTypeAlias node = AstFactory.typeAlias(
-        AstFactory.typeName4("R", []),
+        AstFactory.typeName4("R"),
         "F",
         AstFactory.typeParameterList(["E"]),
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_4());
     _assertReplace(node, new Getter_NodeReplacerTest_test_functionTypeAlias());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypeAlias_2());
     _testAnnotatedNode(node);
   }
 
   void test_functionTypedFormalParameter() {
     FunctionTypedFormalParameter node = AstFactory.functionTypedFormalParameter(
-        AstFactory.typeName4("R", []),
+        AstFactory.typeName4("R"),
         "f",
         [AstFactory.simpleFormalParameter3("p")]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypedFormalParameter());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_functionTypedFormalParameter_2());
     _testNormalFormalParameter(node);
   }
 
   void test_hideCombinator() {
     HideCombinator node = AstFactory.hideCombinator2(["A", "B"]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_hideCombinator(0));
   }
 
   void test_ifStatement() {
     IfStatement node = AstFactory.ifStatement2(
         AstFactory.booleanLiteral(true),
-        AstFactory.block([]),
-        AstFactory.block([]));
+        AstFactory.block(),
+        AstFactory.block());
     _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement());
     _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_3());
     _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_2());
   }
 
   void test_implementsClause() {
     ImplementsClause node = AstFactory.implementsClause(
-        [AstFactory.typeName4("I", []), AstFactory.typeName4("J", [])]);
+        [AstFactory.typeName4("I"), AstFactory.typeName4("J")]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_implementsClause(0));
   }
 
   void test_importDirective() {
     ImportDirective node = AstFactory.importDirective3(
         "",
         "p",
         [AstFactory.showCombinator2(["A"]), AstFactory.hideCombinator2(["B"])]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_importDirective());
     _testNamespaceDirective(node);
   }
 
   void test_indexExpression() {
     IndexExpression node = AstFactory.indexExpression(
         AstFactory.identifier3("a"),
         AstFactory.identifier3("i"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression_2());
   }
 
   void test_instanceCreationExpression() {
     InstanceCreationExpression node = AstFactory.instanceCreationExpression3(
         null,
-        AstFactory.typeName4("C", []),
+        AstFactory.typeName4("C"),
         "c",
         [AstFactory.integer(2)]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_instanceCreationExpression_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_instanceCreationExpression());
   }
 
   void test_interpolationExpression() {
     InterpolationExpression node = AstFactory.interpolationExpression2("x");
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_interpolationExpression());
   }
 
   void test_isExpression() {
     IsExpression node = AstFactory.isExpression(
         AstFactory.identifier3("v"),
         false,
-        AstFactory.typeName4("T", []));
+        AstFactory.typeName4("T"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression_2());
   }
 
   void test_label() {
     Label node = AstFactory.label2("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_label());
   }
 
   void test_labeledStatement() {
     LabeledStatement node = AstFactory.labeledStatement(
-        AstFactory.list([AstFactory.label2("l")]),
-        AstFactory.block([]));
+        [AstFactory.label2("l")],
+        AstFactory.block());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_labeledStatement(0));
     _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
   }
 
   void test_libraryDirective() {
     LibraryDirective node = AstFactory.libraryDirective2("lib");
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_libraryDirective());
     _testAnnotatedNode(node);
   }
 
   void test_libraryIdentifier() {
     LibraryIdentifier node = AstFactory.libraryIdentifier2(["lib"]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
   }
 
   void test_listLiteral() {
     ListLiteral node = AstFactory.listLiteral2(
         null,
-        AstFactory.typeArgumentList([AstFactory.typeName4("E", [])]),
+        AstFactory.typeArgumentList([AstFactory.typeName4("E")]),
         [AstFactory.identifier3("e")]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_listLiteral(0));
     _testTypedLiteral(node);
   }
 
   void test_mapLiteral() {
     MapLiteral node = AstFactory.mapLiteral(
         null,
-        AstFactory.typeArgumentList([AstFactory.typeName4("E", [])]),
+        AstFactory.typeArgumentList([AstFactory.typeName4("E")]),
         [AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v"))]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_mapLiteral(0));
     _testTypedLiteral(node);
   }
 
   void test_mapLiteralEntry() {
     MapLiteralEntry node =
         AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_mapLiteralEntry_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_mapLiteralEntry());
   }
 
   void test_methodDeclaration() {
     MethodDeclaration node = AstFactory.methodDeclaration2(
         null,
-        AstFactory.typeName4("A", []),
+        AstFactory.typeName4("A"),
         null,
         null,
         AstFactory.identifier3("m"),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody(AstFactory.block([])));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody(AstFactory.block()));
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_methodDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_4());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_methodDeclaration_2());
@@ skipping 31 matching lines @@
     ParenthesizedExpression node =
         AstFactory.parenthesizedExpression(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_parenthesizedExpression());
   }
 
   void test_partDirective() {
     PartDirective node = AstFactory.partDirective2("");
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _testUriBasedDirective(node);
   }
 
   void test_partOfDirective() {
     PartOfDirective node =
         AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["lib"]));
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_partOfDirective());
     _testAnnotatedNode(node);
   }
 
   void test_postfixExpression() {
     PostfixExpression node = AstFactory.postfixExpression(
         AstFactory.identifier3("x"),
         TokenType.MINUS_MINUS);
     _assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression());
   }
@@ skipping 37 matching lines @@
 
   void test_showCombinator() {
     ShowCombinator node = AstFactory.showCombinator2(["X", "Y"]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_showCombinator(0));
   }
 
   void test_simpleFormalParameter() {
     SimpleFormalParameter node =
-        AstFactory.simpleFormalParameter4(AstFactory.typeName4("T", []), "p");
+        AstFactory.simpleFormalParameter4(AstFactory.typeName4("T"), "p");
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_simpleFormalParameter());
     _testNormalFormalParameter(node);
   }
 
   void test_stringInterpolation() {
     StringInterpolation node =
         AstFactory.string([AstFactory.interpolationExpression2("a")]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_stringInterpolation(0));
   }
 
   void test_superConstructorInvocation() {
     SuperConstructorInvocation node =
         AstFactory.superConstructorInvocation2("s", [AstFactory.integer(1)]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_superConstructorInvocation());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_superConstructorInvocation_2());
   }
 
   void test_switchCase() {
     SwitchCase node = AstFactory.switchCase2(
-        AstFactory.list([AstFactory.label2("l")]),
+        [AstFactory.label2("l")],
         AstFactory.integer(0),
-        [AstFactory.block([])]);
+        [AstFactory.block()]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_switchCase());
     _testSwitchMember(node);
   }
 
   void test_switchDefault() {
     SwitchDefault node = AstFactory.switchDefault(
-        AstFactory.list([AstFactory.label2("l")]),
-        [AstFactory.block([])]);
+        [AstFactory.label2("l")],
+        [AstFactory.block()]);
     _testSwitchMember(node);
   }
 
   void test_switchStatement() {
     SwitchStatement node = AstFactory.switchStatement(
         AstFactory.identifier3("x"),
         [
             AstFactory.switchCase2(
-                AstFactory.list([AstFactory.label2("l")]),
+                [AstFactory.label2("l")],
                 AstFactory.integer(0),
-                [AstFactory.block([])]),
+                [AstFactory.block()]),
             AstFactory.switchDefault(
-                AstFactory.list([AstFactory.label2("l")]),
-                [AstFactory.block([])])]);
+                [AstFactory.label2("l")],
+                [AstFactory.block()])]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_switchStatement());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_switchStatement(0));
   }
 
   void test_throwExpression() {
     ThrowExpression node =
         AstFactory.throwExpression2(AstFactory.identifier3("e"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_throwExpression());
   }
 
   void test_topLevelVariableDeclaration() {
     TopLevelVariableDeclaration node = AstFactory.topLevelVariableDeclaration(
         null,
-        AstFactory.typeName4("T", []),
+        AstFactory.typeName4("T"),
         [AstFactory.variableDeclaration("t")]);
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_tryStatement() {
     TryStatement node = AstFactory.tryStatement3(
-        AstFactory.block([]),
-        AstFactory.list([AstFactory.catchClause("e", [AstFactory.block([])])]),
-        AstFactory.block([]));
+        AstFactory.block(),
+        [AstFactory.catchClause("e", [AstFactory.block()])],
+        AstFactory.block());
     _assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement());
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_tryStatement(0));
   }
 
   void test_typeArgumentList() {
     TypeArgumentList node =
-        AstFactory.typeArgumentList([AstFactory.typeName4("A", [])]);
+        AstFactory.typeArgumentList([AstFactory.typeName4("A")]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_typeArgumentList(0));
   }
 
   void test_typeName() {
     TypeName node = AstFactory.typeName4(
         "T",
-        [AstFactory.typeName4("E", []), AstFactory.typeName4("F", [])]);
+        [AstFactory.typeName4("E"), AstFactory.typeName4("F")]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeName_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeName());
   }
 
   void test_typeParameter() {
     TypeParameter node =
-        AstFactory.typeParameter2("E", AstFactory.typeName4("B", []));
+        AstFactory.typeParameter2("E", AstFactory.typeName4("B"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter());
   }
 
   void test_typeParameterList() {
     TypeParameterList node = AstFactory.typeParameterList(["A", "B"]);
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_typeParameterList(0));
   }
 
   void test_variableDeclaration() {
     VariableDeclaration node =
         AstFactory.variableDeclaration2("a", AstFactory.nullLiteral());
     node.documentationComment =
-        Comment.createEndOfLineComment(new List<Token>(0));
-    node.metadata =
-        AstFactory.list([AstFactory.annotation(AstFactory.identifier3("a"))]);
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclaration());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclaration_2());
     _testAnnotatedNode(node);
   }
 
   void test_variableDeclarationList() {
     VariableDeclarationList node = AstFactory.variableDeclarationList(
         null,
-        AstFactory.typeName4("T", []),
+        AstFactory.typeName4("T"),
         [AstFactory.variableDeclaration("a")]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclarationList());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_variableDeclarationList(0));
   }
 
   void test_variableDeclarationStatement() {
     VariableDeclarationStatement node = AstFactory.variableDeclarationStatement(
         null,
-        AstFactory.typeName4("T", []),
+        AstFactory.typeName4("T"),
         [AstFactory.variableDeclaration("a")]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclarationStatement());
   }
 
   void test_whileStatement() {
     WhileStatement node = AstFactory.whileStatement(
         AstFactory.booleanLiteral(true),
-        AstFactory.block([]));
+        AstFactory.block());
     _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement());
     _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement_2());
   }
 
   void test_withClause() {
-    WithClause node = AstFactory.withClause([AstFactory.typeName4("M", [])]);
+    WithClause node = AstFactory.withClause([AstFactory.typeName4("M")]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_withClause(0));
   }
 
   void _assertReplace(AstNode parent, NodeReplacerTest_Getter getter) {
     AstNode child = getter.get(parent);
     if (child != null) {
       AstNode clone = child.accept(new AstCloner());
       NodeReplacer.replace(child, clone);
       expect(getter.get(parent), clone);
       expect(clone.parent, parent);
@@ skipping 498 matching lines @@
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }