Create fewer unnecessary lists

pkg/analyzer/test/generated/all_the_rest.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.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 1836 matching lines @@
     local.toolkitObjects = <AngularElement>[angularElement];
     expect(AngularHtmlUnitResolver.getAngularElement(local), same(angularElement));
   }
 
   void test_getAngularElement_notAngular() {
     Element element = ElementFactory.localVariableElement2("name");
     expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
   }
 
   void test_getAngularElement_notLocal() {
-    Element element = ElementFactory.classElement2("Test", []);
+    Element element = ElementFactory.classElement2("Test");
     expect(AngularHtmlUnitResolver.getAngularElement(element), isNull);
   }
 
   /**
    * Test that we resolve "ng-click" expression.
    */
   void test_ngClick() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController(r"<button ng-click='ctrl.doSomething($event)'/>"));
@@ skipping 726 matching lines @@
    * Assert that the number of errors reported against the given source matches the number of errors
    * that are given and that they have the expected error codes. The order in which the errors were
    * gathered is ignored.
    *
    * @param source the source against which the errors should have been reported
    * @param expectedErrorCodes the error codes of the errors that should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if a different number of errors have been reported than were
    *           expected
    */
-  void assertErrors(Source source, List<ErrorCode> expectedErrorCodes) {
+  void assertErrors(Source source, [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     AnalysisErrorInfo errorsInfo = context.getErrors(source);
     for (AnalysisError error in errorsInfo.errors) {
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void assertMainErrors(List<ErrorCode> expectedErrorCodes) {
     assertErrors(mainSource, expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been reported against the [indexSource].
    */
   void assertNoErrors() {
-    assertErrors(indexSource, []);
+    assertErrors(indexSource);
   }
 
   void assertNoErrors2(Source source) {
-    assertErrors(source, []);
+    assertErrors(source);
   }
 
   /**
    * Assert that no errors have been reported against the [mainSource].
    */
   void assertNoMainErrors() {
-    assertErrors(mainSource, []);
+    assertErrors(mainSource);
   }
 
   /**
    * Checks that [indexHtmlUnit] has [SimpleIdentifier] with given name, resolved to
    * not `null` [Element].
    */
   Element assertResolvedIdentifier(String name) {
     SimpleIdentifier identifier = findIdentifier(name);
     // check Element
     Element element = identifier.bestElement;
@@ skipping 820 matching lines @@
   }
 
   ConstructorElement _setupConstructorDeclaration(String name, bool isConst) {
     Keyword constKeyword = isConst ? Keyword.CONST : null;
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             constKeyword,
             null,
             null,
             name,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([]));
-    ClassElement classElement = ElementFactory.classElement2(name, []);
+            AstFactory.blockFunctionBody2());
+    ClassElement classElement = ElementFactory.classElement2(name);
     ConstructorElement element =
-        ElementFactory.constructorElement(classElement, name, isConst, []);
+        ElementFactory.constructorElement(classElement, name, isConst);
     constructorDeclaration.element = element;
     _node = constructorDeclaration;
     return element;
   }
 
   void _setupInstanceCreationExpression(String name, bool isConst) {
     _node = AstFactory.instanceCreationExpression2(
         isConst ? Keyword.CONST : null,
-        AstFactory.typeName3(AstFactory.identifier3(name), []),
-        []);
+        AstFactory.typeName3(AstFactory.identifier3(name)));
   }
 
   VariableElement _setupVariableDeclaration(String name, bool isConst,
       bool isInitialized) {
     VariableDeclaration variableDeclaration = isInitialized ?
         AstFactory.variableDeclaration2(name, AstFactory.integer(0)) :
         AstFactory.variableDeclaration(name);
     SimpleIdentifier identifier = variableDeclaration.name;
     VariableElement element = ElementFactory.localVariableElement(identifier);
     identifier.staticElement = element;
@@ skipping 103 matching lines @@
     expect(members, hasLength(1));
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_dependencyOnConstructor() {
     // x depends on "const A()"
     _assertProperDependencies(r'''
 class A {
   const A();
 }
-const x = const A();''',
-        []);
+const x = const A();''');
   }
 
   void test_dependencyOnConstructorArgument() {
     // "const A(x)" depends on x
     _assertProperDependencies(r'''
 class A {
   const A(this.next);
   final A next;
 }
 const A x = const A(null);
-const A y = const A(x);''',
-        []);
+const A y = const A(x);''');
   }
 
   void test_dependencyOnConstructorArgument_unresolvedConstructor() {
     // "const A.a(x)" depends on x even if the constructor A.a can't be found.
     _assertProperDependencies(r'''
 class A {
 }
 const int x = 1;
 const A y = const A.a(x);''',
         [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
   }
 
   void test_dependencyOnConstructorInitializer() {
     // "const A()" depends on x
     _assertProperDependencies(r'''
 const int x = 1;
 class A {
   const A() : v = x;
   final int v;
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnExplicitSuperConstructor() {
     // b depends on B() depends on A()
     _assertProperDependencies(r'''
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B() : super(5);
 }
-const B b = const B();''',
-        []);
+const B b = const B();''');
   }
 
   void test_dependencyOnExplicitSuperConstructorParameters() {
     // b depends on B() depends on i
     _assertProperDependencies(r'''
 class A {
   const A(this.x);
   final int x;
 }
 class B extends A {
   const B() : super(i);
 }
 const B b = const B();
-const int i = 5;''',
-        []);
+const int i = 5;''');
   }
 
   void test_dependencyOnFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   factory const A.foo() = A.bar;
   const A.bar();
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnFactoryRedirectWithTypeParams() {
     _assertProperDependencies(r'''
 class A {
   const factory A(var a) = B<int>;
 }
 
 class B<T> implements A {
   final T x;
   const B(this.x);
 }
 
-const A a = const A(10);''',
-        []);
+const A a = const A(10);''');
   }
 
   void test_dependencyOnImplicitSuperConstructor() {
     // b depends on B() depends on A()
     _assertProperDependencies(r'''
 class A {
   const A() : x = 5;
   final int x;
 }
 class B extends A {
   const B();
 }
-const B b = const B();''',
-        []);
+const B b = const B();''');
   }
 
   void test_dependencyOnNonFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   const A.bar();
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnNonFactoryRedirect_arg() {
     // a depends on A.foo() depends on b
     _assertProperDependencies(r'''
 const A a = const A.foo();
 const int b = 1;
 class A {
   const A.foo() : this.bar(b);
   const A.bar(x) : y = x;
   final int y;
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnNonFactoryRedirect_defaultValue() {
     // a depends on A.foo() depends on A.bar() depends on b
     _assertProperDependencies(r'''
 const A a = const A.foo();
 const int b = 1;
 class A {
   const A.foo() : this.bar();
   const A.bar([x = b]) : y = x;
   final int y;
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnNonFactoryRedirect_toMissing() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // missing.
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
 }''',
         [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
   }
 
   void test_dependencyOnNonFactoryRedirect_toNonConst() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // non-const.
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this.bar();
   A.bar();
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnNonFactoryRedirect_unnamed() {
     // a depends on A.foo() depends on A()
     _assertProperDependencies(r'''
 const A a = const A.foo();
 class A {
   const A.foo() : this();
   const A();
-}''',
-        []);
+}''');
   }
 
   void test_dependencyOnOptionalParameterDefault() {
     // a depends on A() depends on B()
     _assertProperDependencies(r'''
 class A {
   const A([x = const B()]) : b = x;
   final B b;
 }
 class B {
   const B();
 }
-const A a = const A();''',
-        []);
+const A a = const A();''');
   }
 
   void test_dependencyOnVariable() {
     // x depends on y
     _assertProperDependencies(r'''
 const x = y + 1;
-const y = 2;''',
-        []);
+const y = 2;''');
   }
 
   void test_fromEnvironment_bool_default_false() {
     expect(_assertValidBool(_check_fromEnvironment_bool(null, "false")), false);
   }
 
   void test_fromEnvironment_bool_default_overridden() {
     expect(_assertValidBool(_check_fromEnvironment_bool("false", "true")), false);
   }
 
@@ skipping 523 matching lines @@
     expect(field.type.name, "int");
     expect(field.intValue, expectedValue);
   }
 
   void _assertNullField(Map<String, DartObjectImpl> fields, String fieldName) {
     DartObjectImpl field = fields[fieldName];
     expect(field.isNull, isTrue);
   }
 
   void _assertProperDependencies(String sourceText,
-      List<ErrorCode> expectedErrorCodes) {
+      [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     Source source = addSource(sourceText);
     LibraryElement element = resolve(source);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(source, element);
     expect(unit, isNotNull);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     assertErrors(source, expectedErrorCodes);
   }
@@ skipping 199 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         0,
         expression.accept(
             new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
-  void
-      test_visitConditionalExpression_instanceCreation_invalidFieldInitializer() {
+  void test_visitConditionalExpression_instanceCreation_invalidFieldInitializer() {
     TestTypeProvider typeProvider = new TestTypeProvider();
     LibraryElementImpl libraryElement = ElementFactory.library(null, "lib");
     String className = "C";
-    ClassElementImpl classElement = ElementFactory.classElement2(className, []);
+    ClassElementImpl classElement = ElementFactory.classElement2(className);
     (libraryElement.definingCompilationUnit as CompilationUnitElementImpl).types =
         <ClassElement>[classElement];
     ConstructorElementImpl constructorElement =
         ElementFactory.constructorElement(
             classElement,
             null,
             true,
             [typeProvider.intType]);
     constructorElement.parameters[0] =
         new FieldFormalParameterElementImpl(AstFactory.identifier3("x"));
     InstanceCreationExpression expression =
         AstFactory.instanceCreationExpression2(
             Keyword.CONST,
-            AstFactory.typeName4(className, []),
+            AstFactory.typeName4(className),
             [AstFactory.integer(0)]);
     expression.staticElement = constructorElement;
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ErrorReporter errorReporter =
         new ErrorReporter(errorListener, _dummySource());
     expression.accept(new ConstantVisitor.con1(typeProvider, errorReporter));
     errorListener.assertErrorsWithCodes(
         [CompileTimeErrorCode.INVALID_CONSTANT]);
   }
 
@@ skipping 410 matching lines @@
 
   void test_equalEqual_int_true() {
     _assertEqualEqual(_boolValue(true), _intValue(5), _intValue(5));
   }
 
   void test_equalEqual_int_unknown() {
     _assertEqualEqual(_boolValue(null), _intValue(null), _intValue(3));
   }
 
   void test_equalEqual_list_empty() {
-    _assertEqualEqual(null, _listValue([]), _listValue([]));
+    _assertEqualEqual(null, _listValue(), _listValue());
   }
 
   void test_equalEqual_list_false() {
-    _assertEqualEqual(null, _listValue([]), _listValue([]));
+    _assertEqualEqual(null, _listValue(), _listValue());
   }
 
   void test_equalEqual_map_empty() {
-    _assertEqualEqual(null, _mapValue([]), _mapValue([]));
+    _assertEqualEqual(null, _mapValue(), _mapValue());
   }
 
   void test_equalEqual_map_false() {
-    _assertEqualEqual(null, _mapValue([]), _mapValue([]));
+    _assertEqualEqual(null, _mapValue(), _mapValue());
   }
 
   void test_equalEqual_null() {
     _assertEqualEqual(_boolValue(true), _nullValue(), _nullValue());
   }
 
   void test_equalEqual_string_false() {
     _assertEqualEqual(
         _boolValue(false),
         _stringValue("abc"),
@@ skipping 17 matching lines @@
   void test_equals_list_false_differentSizes() {
     expect(_listValue([_boolValue(true)]) ==
             _listValue([_boolValue(true), _boolValue(false)]), isFalse);
   }
 
   void test_equals_list_false_sameSize() {
     expect(_listValue([_boolValue(true)]) == _listValue([_boolValue(false)]), isFalse);
   }
 
   void test_equals_list_true_empty() {
-    expect(_listValue([]), _listValue([]));
+    expect(_listValue(), _listValue());
   }
 
   void test_equals_list_true_nonEmpty() {
     expect(_listValue([_boolValue(true)]), _listValue([_boolValue(true)]));
   }
 
   void test_equals_map_true_empty() {
-    expect(_mapValue([]), _mapValue([]));
+    expect(_mapValue(), _mapValue());
   }
 
   void test_equals_symbol_false() {
     expect(_symbolValue("a") == _symbolValue("b"), isFalse);
   }
 
   void test_equals_symbol_true() {
     expect(_symbolValue("a"), _symbolValue("a"));
   }
 
@@ skipping 21 matching lines @@
   void test_getValue_int_known() {
     int value = 23;
     expect(_intValue(value).value, value);
   }
 
   void test_getValue_int_unknown() {
     expect(_intValue(null).value, isNull);
   }
 
   void test_getValue_list_empty() {
-    Object result = _listValue([]).value;
+    Object result = _listValue().value;
     _assertInstanceOfObjectArray(result);
     List<Object> array = result as List<Object>;
     expect(array, hasLength(0));
   }
 
   void test_getValue_list_valid() {
     Object result = _listValue([_intValue(23)]).value;
     _assertInstanceOfObjectArray(result);
     List<Object> array = result as List<Object>;
     expect(array, hasLength(1));
   }
 
   void test_getValue_map_empty() {
-    Object result = _mapValue([]).value;
+    Object result = _mapValue().value;
     EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
     Map map = result as Map;
     expect(map, hasLength(0));
   }
 
   void test_getValue_map_valid() {
     Object result =
         _mapValue([_stringValue("key"), _stringValue("value")]).value;
     EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, result);
     Map map = result as Map;
@@ skipping 197 matching lines @@
 
   void test_hasExactValue_int_known() {
     expect(_intValue(23).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_int_unknown() {
     expect(_intValue(null).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_list_empty() {
-    expect(_listValue([]).hasExactValue, isTrue);
+    expect(_listValue().hasExactValue, isTrue);
   }
 
   void test_hasExactValue_list_invalid() {
     expect(_dynamicValue().hasExactValue, isFalse);
   }
 
   void test_hasExactValue_list_valid() {
     expect(_listValue([_intValue(23)]).hasExactValue, isTrue);
   }
 
   void test_hasExactValue_map_empty() {
-    expect(_mapValue([]).hasExactValue, isTrue);
+    expect(_mapValue().hasExactValue, isTrue);
   }
 
   void test_hasExactValue_map_invalidKey() {
     expect(_mapValue([_dynamicValue(), _stringValue("value")]).hasExactValue, isFalse);
   }
 
   void test_hasExactValue_map_invalidValue() {
     expect(_mapValue([_stringValue("key"), _dynamicValue()]).hasExactValue, isFalse);
   }
 
@@ skipping 47 matching lines @@
 
   void test_identical_int_true() {
     _assertIdentical(_boolValue(true), _intValue(5), _intValue(5));
   }
 
   void test_identical_int_unknown() {
     _assertIdentical(_boolValue(null), _intValue(null), _intValue(3));
   }
 
   void test_identical_list_empty() {
-    _assertIdentical(_boolValue(true), _listValue([]), _listValue([]));
+    _assertIdentical(_boolValue(true), _listValue(), _listValue());
   }
 
   void test_identical_list_false() {
-    _assertIdentical(_boolValue(false), _listValue([]),
+    _assertIdentical(_boolValue(false), _listValue(),
         _listValue([_intValue(3)]));
   }
 
   void test_identical_map_empty() {
-    _assertIdentical(_boolValue(true), _mapValue([]), _mapValue([]));
+    _assertIdentical(_boolValue(true), _mapValue(), _mapValue());
   }
 
   void test_identical_map_false() {
-    _assertIdentical(_boolValue(false), _mapValue([]),
+    _assertIdentical(_boolValue(false), _mapValue(),
         _mapValue([_intValue(1), _intValue(2)]));
   }
 
   void test_identical_null() {
     _assertIdentical(_boolValue(true), _nullValue(), _nullValue());
   }
 
   void test_identical_string_false() {
     _assertIdentical(
         _boolValue(false),
@@ skipping 99 matching lines @@
 
   void test_isBoolNumStringOrNull_int_known() {
     expect(_intValue(23).isBoolNumStringOrNull, isTrue);
   }
 
   void test_isBoolNumStringOrNull_int_unknown() {
     expect(_intValue(null).isBoolNumStringOrNull, isTrue);
   }
 
   void test_isBoolNumStringOrNull_list() {
-    expect(_listValue([]).isBoolNumStringOrNull, isFalse);
+    expect(_listValue().isBoolNumStringOrNull, isFalse);
   }
 
   void test_isBoolNumStringOrNull_null() {
     expect(_nullValue().isBoolNumStringOrNull, isTrue);
   }
 
   void test_isBoolNumStringOrNull_num() {
     expect(_numValue().isBoolNumStringOrNull, isTrue);
   }
 
@@ skipping 1354 matching lines @@
   }
 
   DartObjectImpl _intValue(int value) {
     if (value == null) {
       return new DartObjectImpl(_typeProvider.intType, IntState.UNKNOWN_VALUE);
     } else {
       return new DartObjectImpl(_typeProvider.intType, new IntState(value));
     }
   }
 
-  DartObjectImpl _listValue(List<DartObjectImpl> elements) {
+  DartObjectImpl _listValue([List<DartObjectImpl> elements = DartObjectImpl.EMPTY_LIST]) {
     return new DartObjectImpl(_typeProvider.listType, new ListState(elements));
   }
 
-  DartObjectImpl _mapValue(List<DartObjectImpl> keyElementPairs) {
+  DartObjectImpl _mapValue([List<DartObjectImpl> keyElementPairs = DartObjectImpl.EMPTY_LIST]) {
     Map<DartObjectImpl, DartObjectImpl> map =
         new Map<DartObjectImpl, DartObjectImpl>();
     int count = keyElementPairs.length;
     for (int i = 0; i < count; ) {
       map[keyElementPairs[i++]] = keyElementPairs[i++];
     }
     return new DartObjectImpl(_typeProvider.mapType, new MapState(map));
   }
 
   DartObjectImpl _nullValue() {
@@ skipping 290 matching lines @@
 }
 
 
 class ElementBuilderTest extends EngineTestCase {
   void test_visitCatchClause() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String exceptionParameterName = "e";
     String stackParameterName = "s";
     CatchClause clause =
-        AstFactory.catchClause2(exceptionParameterName, stackParameterName, []);
+        AstFactory.catchClause2(exceptionParameterName, stackParameterName);
     clause.accept(builder);
     List<LocalVariableElement> variables = holder.localVariables;
     expect(variables, hasLength(2));
     VariableElement exceptionVariable = variables[0];
     expect(exceptionVariable, isNotNull);
     expect(exceptionVariable.name, exceptionParameterName);
     expect(exceptionVariable.isSynthetic, isFalse);
     expect(exceptionVariable.isConst, isFalse);
     expect(exceptionVariable.isFinal, isFalse);
     expect(exceptionVariable.initializer, isNull);
     VariableElement stackVariable = variables[1];
     expect(stackVariable, isNotNull);
     expect(stackVariable.name, stackParameterName);
     expect(stackVariable.isSynthetic, isFalse);
     expect(stackVariable.isConst, isFalse);
     expect(stackVariable.isFinal, isFalse);
     expect(stackVariable.initializer, isNull);
   }
 
   void test_visitClassDeclaration_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(
         Keyword.ABSTRACT,
         className,
         null,
         null,
         null,
-        null,
-        []);
+        null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isTrue);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     ClassDeclaration classDeclaration =
-        AstFactory.classDeclaration(null, className, null, null, null, null, []);
+        AstFactory.classDeclaration(null, className, null, null, null, null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(0));
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
   }
 
   void test_visitClassDeclaration_parameterized() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "C";
     String firstVariableName = "E";
     String secondVariableName = "F";
     ClassDeclaration classDeclaration = AstFactory.classDeclaration(
         null,
         className,
         AstFactory.typeParameterList([firstVariableName, secondVariableName]),
         null,
         null,
-        null,
-        []);
+        null);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(2));
     expect(typeParameters[0].name, firstVariableName);
     expect(typeParameters[1].name, secondVariableName);
@@ skipping 19 matching lines @@
             AstFactory.fieldDeclaration2(
                 false,
                 null,
                 [AstFactory.variableDeclaration(fieldName)]),
             AstFactory.methodDeclaration2(
                 null,
                 null,
                 null,
                 null,
                 AstFactory.identifier3(methodName),
-                AstFactory.formalParameterList([]),
-                AstFactory.blockFunctionBody2([]))]);
+                AstFactory.formalParameterList(),
+                AstFactory.blockFunctionBody2())]);
     classDeclaration.accept(builder);
     List<ClassElement> types = holder.types;
     expect(types, hasLength(1));
     ClassElement type = types[0];
     expect(type, isNotNull);
     expect(type.name, className);
     expect(type.isAbstract, isFalse);
     expect(type.isSynthetic, isFalse);
     List<TypeParameterElement> typeParameters = type.typeParameters;
     expect(typeParameters, hasLength(1));
@@ skipping 15 matching lines @@
   void test_visitConstructorDeclaration_factory() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             Keyword.FACTORY,
             AstFactory.identifier3(className),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([]));
+            AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isTrue);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([]));
+            AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_named() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     String constructorName = "c";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             constructorName,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([]));
+            AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, constructorName);
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.name.staticElement, same(constructor));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitConstructorDeclaration_unnamed() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3(className),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             null,
-            AstFactory.blockFunctionBody2([]));
+            AstFactory.blockFunctionBody2());
     constructorDeclaration.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
@@ skipping 106 matching lines @@
 
   void test_visitFunctionDeclaration_getter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         Keyword.GET,
         functionName,
         AstFactory.functionExpression2(
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
     declaration.accept(builder);
     List<PropertyAccessorElement> accessors = holder.accessors;
     expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     expect(accessor.name, functionName);
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.isGetter, isTrue);
     expect(accessor.isSetter, isFalse);
     expect(accessor.isSynthetic, isFalse);
     PropertyInducingElement variable = accessor.variable;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         variable);
     expect(variable.isSynthetic, isTrue);
   }
 
   void test_visitFunctionDeclaration_plain() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         null,
         functionName,
         AstFactory.functionExpression2(
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
     declaration.accept(builder);
     List<FunctionElement> functions = holder.functions;
     expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     expect(function.name, functionName);
     expect(declaration.element, same(function));
     expect(declaration.functionExpression.element, same(function));
     expect(function.isSynthetic, isFalse);
   }
 
   void test_visitFunctionDeclaration_setter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String functionName = "f";
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         Keyword.SET,
         functionName,
         AstFactory.functionExpression2(
-            AstFactory.formalParameterList([]),
-            AstFactory.blockFunctionBody2([])));
+            AstFactory.formalParameterList(),
+            AstFactory.blockFunctionBody2()));
     declaration.accept(builder);
     List<PropertyAccessorElement> accessors = holder.accessors;
     expect(accessors, hasLength(1));
     PropertyAccessorElement accessor = accessors[0];
     expect(accessor, isNotNull);
     expect(accessor.name, "$functionName=");
     expect(declaration.element, same(accessor));
     expect(declaration.functionExpression.element, same(accessor));
     expect(accessor.isGetter, isFalse);
     expect(accessor.isSetter, isTrue);
     expect(accessor.isSynthetic, isFalse);
     PropertyInducingElement variable = accessor.variable;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         variable);
     expect(variable.isSynthetic, isTrue);
   }
 
   void test_visitFunctionExpression() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     FunctionExpression expression = AstFactory.functionExpression2(
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     expression.accept(builder);
     List<FunctionElement> functions = holder.functions;
     expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     expect(expression.element, same(function));
     expect(function.isSynthetic, isFalse);
   }
 
   void test_visitFunctionTypeAlias() {
@@ skipping 18 matching lines @@
     TypeParameterElement typeParameter = typeParameters[0];
     expect(typeParameter, isNotNull);
     expect(typeParameter.name, parameterName);
   }
 
   void test_visitFunctionTypedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String parameterName = "p";
     FunctionTypedFormalParameter formalParameter =
-        AstFactory.functionTypedFormalParameter(null, parameterName, []);
+        AstFactory.functionTypedFormalParameter(null, parameterName);
     _useParameterInMethod(formalParameter, 100, 110);
     formalParameter.accept(builder);
     List<ParameterElement> parameters = holder.parameters;
     expect(parameters, hasLength(1));
     ParameterElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
     {
       SourceRange visibleRange = parameter.visibleRange;
       expect(100, visibleRange.offset);
       expect(110, visibleRange.end);
     }
   }
 
   void test_visitLabeledStatement() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String labelName = "l";
     LabeledStatement statement = AstFactory.labeledStatement(
-        AstFactory.list([AstFactory.label2(labelName)]),
+        [AstFactory.label2(labelName)],
         AstFactory.breakStatement());
     statement.accept(builder);
     List<LabelElement> labels = holder.labels;
     expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
     expect(label.name, labelName);
     expect(label.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.isAbstract, isTrue);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_getter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
@@ skipping 11 matching lines @@
   void test_visitMethodDeclaration_getter_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
@@ skipping 12 matching lines @@
   void test_visitMethodDeclaration_getter_external() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
         null,
         null,
         Keyword.GET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     expect(getter, isNotNull);
@@ skipping 11 matching lines @@
   void test_visitMethodDeclaration_minimal() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_operator() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "+";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         Keyword.OPERATOR,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("addend")]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.blockFunctionBody2());
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(1));
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_setter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
@@ skipping 12 matching lines @@
   void test_visitMethodDeclaration_setter_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         AstFactory.emptyFunctionBody());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
@@ skipping 13 matching lines @@
   void test_visitMethodDeclaration_setter_external() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
         null,
         null,
         Keyword.SET,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     methodDeclaration.accept(builder);
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElement field = fields[0];
     expect(field, isNotNull);
     expect(field.name, methodName);
     expect(field.isSynthetic, isTrue);
     expect(field.getter, isNull);
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
@@ skipping 12 matching lines @@
   void test_visitMethodDeclaration_static() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         Keyword.STATIC,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList([]),
-        AstFactory.blockFunctionBody2([]));
+        AstFactory.formalParameterList(),
+        AstFactory.blockFunctionBody2());
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
@@ skipping 11 matching lines @@
     String labelName = "l";
     String exceptionParameterName = "e";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList(
             [AstFactory.simpleFormalParameter3(parameterName)]),
-        AstFactory.blockFunctionBody2(
-            [
-                AstFactory.variableDeclarationStatement2(
-                    Keyword.VAR,
-                    [AstFactory.variableDeclaration(localVariableName)]),
-                AstFactory.tryStatement2(
-                    AstFactory.block(
-                        [
-                            AstFactory.labeledStatement(
-                                AstFactory.list([AstFactory.label2(labelName)]),
-                                AstFactory.returnStatement())]),
-                    [AstFactory.catchClause(exceptionParameterName, [])])]));
+        AstFactory.blockFunctionBody2([
+            AstFactory.variableDeclarationStatement2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration(localVariableName)]),
+            AstFactory.tryStatement2(
+                AstFactory.block([AstFactory.labeledStatement(
+                    [AstFactory.label2(labelName)],
+                    AstFactory.returnStatement())]),
+                [AstFactory.catchClause(exceptionParameterName)])]));
     methodDeclaration.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.name, methodName);
     expect(method.isAbstract, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
     List<VariableElement> parameters = method.parameters;
@@ skipping 89 matching lines @@
 
   void test_visitTypeAlias_withFormalParameters() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     String firstParameterName = "x";
     String secondParameterName = "y";
     TypeAlias typeAlias = AstFactory.typeAlias(
         null,
         aliasName,
-        AstFactory.typeParameterList([]),
+        AstFactory.typeParameterList(),
         AstFactory.formalParameterList(
             [
                 AstFactory.simpleFormalParameter3(firstParameterName),
                 AstFactory.simpleFormalParameter3(secondParameterName)]));
     typeAlias.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
     expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
@@ skipping 11 matching lines @@
   void test_visitTypeAlias_withTypeParameters() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     String aliasName = "F";
     String firstTypeParameterName = "A";
     String secondTypeParameterName = "B";
     TypeAlias typeAlias = AstFactory.typeAlias(
         null,
         aliasName,
         AstFactory.typeParameterList([firstTypeParameterName, secondTypeParameterName]),
-        AstFactory.formalParameterList([]));
+        AstFactory.formalParameterList());
     typeAlias.accept(builder);
     List<FunctionTypeAliasElement> aliases = holder.typeAliases;
     expect(aliases, hasLength(1));
     FunctionTypeAliasElement alias = aliases[0];
     expect(alias, isNotNull);
     expect(alias.name, aliasName);
     expect(alias.type, isNotNull);
     expect(alias.isSynthetic, isFalse);
     List<VariableElement> parameters = alias.parameters;
     expect(parameters, isNotNull);
@@ skipping 28 matching lines @@
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     ConstructorDeclaration constructor = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         "C",
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         null,
         AstFactory.blockFunctionBody2([statement]));
     constructor.accept(builder);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     List<LocalVariableElement> variableElements =
         constructors[0].localVariables;
     expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
     expect(variableElement.name, variableName);
   }
 
   void test_visitVariableDeclaration_inMethod() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     //
     // m() {var v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     MethodDeclaration constructor = AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3("m"),
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         AstFactory.blockFunctionBody2([statement]));
     constructor.accept(builder);
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     List<LocalVariableElement> variableElements = methods[0].localVariables;
     expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
     expect(variableElement.name, variableName);
   }
 
   void test_visitVariableDeclaration_localNestedInField() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     //
     // var f = () {var v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstFactory.variableDeclarationStatement2(null, [variable]);
     Expression initializer = AstFactory.functionExpression2(
-        AstFactory.formalParameterList([]),
+        AstFactory.formalParameterList(),
         AstFactory.blockFunctionBody2([statement]));
     String fieldName = "f";
     VariableDeclaration field =
         AstFactory.variableDeclaration2(fieldName, initializer);
     FieldDeclaration fieldDeclaration =
         AstFactory.fieldDeclaration2(false, null, [field]);
     fieldDeclaration.accept(builder);
     List<FieldElement> variables = holder.fields;
     expect(variables, hasLength(1));
     FieldElement fieldElement = variables[0];
@@ skipping 28 matching lines @@
     expect(variable.name, variableName);
     expect(variable.isConst, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isSynthetic, isFalse);
     expect(variable.getter, isNotNull);
     expect(variable.setter, isNotNull);
   }
 
   void _useParameterInMethod(FormalParameter formalParameter, int blockOffset,
       int blockEnd) {
-    Block block = AstFactory.block([]);
+    Block block = AstFactory.block();
     block.leftBracket.offset = blockOffset;
     block.rightBracket.offset = blockEnd - 1;
     BlockFunctionBody body = AstFactory.blockFunctionBody(block);
     AstFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstFactory.identifier3("main"),
         AstFactory.formalParameterList([formalParameter]),
@@ skipping 248 matching lines @@
   }
 
   void test_locate_InstanceCreationExpression_type_prefixedIdentifier() {
     // prepare: new pref.A()
     SimpleIdentifier identifier = AstFactory.identifier3("A");
     PrefixedIdentifier prefixedIdentifier =
         AstFactory.identifier4("pref", identifier);
     InstanceCreationExpression creation =
         AstFactory.instanceCreationExpression2(
             Keyword.NEW,
-            AstFactory.typeName3(prefixedIdentifier, []),
-            []);
+            AstFactory.typeName3(prefixedIdentifier));
     // set ClassElement
-    ClassElement classElement = ElementFactory.classElement2("A", []);
+    ClassElement classElement = ElementFactory.classElement2("A");
     identifier.staticElement = classElement;
     // set ConstructorElement
     ConstructorElement constructorElement =
-        ElementFactory.constructorElement2(classElement, null, []);
+        ElementFactory.constructorElement2(classElement, null);
     creation.constructorName.staticElement = constructorElement;
     // verify that "A" is resolved to ConstructorElement
     Element element = ElementLocator.locate(identifier);
     expect(element, same(classElement));
   }
 
   void test_locate_InstanceCreationExpression_type_simpleIdentifier() {
     // prepare: new A()
     SimpleIdentifier identifier = AstFactory.identifier3("A");
     InstanceCreationExpression creation =
         AstFactory.instanceCreationExpression2(
             Keyword.NEW,
-            AstFactory.typeName3(identifier, []),
-            []);
+            AstFactory.typeName3(identifier));
     // set ClassElement
-    ClassElement classElement = ElementFactory.classElement2("A", []);
+    ClassElement classElement = ElementFactory.classElement2("A");
     identifier.staticElement = classElement;
     // set ConstructorElement
     ConstructorElement constructorElement =
-        ElementFactory.constructorElement2(classElement, null, []);
+        ElementFactory.constructorElement2(classElement, null);
     creation.constructorName.staticElement = constructorElement;
     // verify that "A" is resolved to ConstructorElement
     Element element = ElementLocator.locate(identifier);
     expect(element, same(classElement));
   }
 
   void test_locate_LibraryDirective() {
     AstNode id = _findNodeIn("library", "library foo;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
@@ skipping 283 matching lines @@
 class ErrorReporterTest extends EngineTestCase {
   /**
    * Create a type with the given name in a compilation unit with the given name.
    *
    * @param fileName the name of the compilation unit containing the class
    * @param typeName the name of the type to be created
    * @return the type that was created
    */
   InterfaceType createType(String fileName, String typeName) {
     CompilationUnitElementImpl unit = ElementFactory.compilationUnit(fileName);
-    ClassElementImpl element = ElementFactory.classElement2(typeName, []);
+    ClassElementImpl element = ElementFactory.classElement2(typeName);
     unit.types = <ClassElement>[element];
     return element.type;
   }
 
   void test_creation() {
     GatheringErrorListener listener = new GatheringErrorListener();
     TestSource source = new TestSource();
     expect(new ErrorReporter(listener, source), isNotNull);
   }
 
@@ skipping 539 matching lines @@
   void test_whileStatement_true_throw() {
     _assertTrue("{ while (true) { throw ''; } }");
   }
 
   void _assertFalse(String source) {
     _assertHasReturn(false, source);
   }
 
   void _assertHasReturn(bool expectedResult, String source) {
     ExitDetector detector = new ExitDetector();
-    Statement statement = ParserTestCase.parseStatement(source, []);
+    Statement statement = ParserTestCase.parseStatement(source);
     expect(statement.accept(detector), same(expectedResult));
   }
 
   void _assertTrue(String source) {
     _assertHasReturn(true, source);
   }
 }
 
 
 class ExpressionVisitor_AngularTest_verify extends ExpressionVisitor {
@@ skipping 267 matching lines @@
   </body>
 </html>""");
     _validate(
         htmlUnit,
         [
             _t4(
                 "html",
                 [
                     _t4(
                         "body",
-                        [_t("script", _a(["type", "'application/dart'"]), scriptBody, [])])])]);
+                        [_t("script", _a(["type", "'application/dart'"]), scriptBody)])])]);
   }
   ht.HtmlUnit parse(String contents) {
 //    TestSource source =
 //        new TestSource.con1(FileUtilities2.createFile("/test.dart"), contents);
     ht.AbstractScanner scanner = new ht.StringScanner(null, contents);
     scanner.passThroughElements = <String>[_TAG_SCRIPT];
     ht.Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ht.HtmlUnit unit =
         new ht.HtmlParser(null, errorListener).parse(token, lineInfo);
     errorListener.assertNoErrors();
     return unit;
   }
   void test_parse_attribute() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsdf\"></body></html>");
     _validate(
         htmlUnit,
-        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "", [])])]);
+        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "")])]);
     ht.XmlTagNode htmlNode = htmlUnit.tagNodes[0];
     ht.XmlTagNode bodyNode = htmlNode.tagNodes[0];
     expect(bodyNode.attributes[0].text, "sdfsdf");
   }
   void test_parse_attribute_EOF() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsdf\"");
     _validate(
         htmlUnit,
-        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "", [])])]);
+        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "")])]);
   }
   void test_parse_attribute_EOF_missing_quote() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsd");
     _validate(
         htmlUnit,
-        [_t4("html", [_t("body", _a(["foo", "\"sdfsd"]), "", [])])]);
+        [_t4("html", [_t("body", _a(["foo", "\"sdfsd"]), "")])]);
     ht.XmlTagNode htmlNode = htmlUnit.tagNodes[0];
     ht.XmlTagNode bodyNode = htmlNode.tagNodes[0];
     expect(bodyNode.attributes[0].text, "sdfsd");
   }
   void test_parse_attribute_extra_quote() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsdf\"\"></body></html>");
     _validate(
         htmlUnit,
-        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "", [])])]);
+        [_t4("html", [_t("body", _a(["foo", "\"sdfsdf\""]), "")])]);
   }
   void test_parse_attribute_single_quote() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo='sdfsdf'></body></html>");
     _validate(
         htmlUnit,
-        [_t4("html", [_t("body", _a(["foo", "'sdfsdf'"]), "", [])])]);
+        [_t4("html", [_t("body", _a(["foo", "'sdfsdf'"]), "")])]);
     ht.XmlTagNode htmlNode = htmlUnit.tagNodes[0];
     ht.XmlTagNode bodyNode = htmlNode.tagNodes[0];
     expect(bodyNode.attributes[0].text, "sdfsdf");
   }
   void test_parse_comment_embedded() {
     ht.HtmlUnit htmlUnit = parse("<html <!-- comment -->></html>");
-    _validate(htmlUnit, [_t3("html", "", [])]);
+    _validate(htmlUnit, [_t3("html", "")]);
   }
   void test_parse_comment_first() {
     ht.HtmlUnit htmlUnit = parse("<!-- comment --><html></html>");
-    _validate(htmlUnit, [_t3("html", "", [])]);
+    _validate(htmlUnit, [_t3("html", "")]);
   }
   void test_parse_comment_in_content() {
     ht.HtmlUnit htmlUnit = parse("<html><!-- comment --></html>");
-    _validate(htmlUnit, [_t3("html", "<!-- comment -->", [])]);
+    _validate(htmlUnit, [_t3("html", "<!-- comment -->")]);
   }
   void test_parse_content() {
     ht.HtmlUnit htmlUnit = parse("<html>\n<p a=\"b\">blat \n </p>\n</html>");
     // ht.XmlTagNode.getContent() does not include whitespace
     // between '<' and '>' at this time
     _validate(
         htmlUnit,
         [
             _t3(
                 "html",
                 "\n<pa=\"b\">blat \n </p>\n",
-                [_t("p", _a(["a", "\"b\""]), "blat \n ", [])])]);
+                [_t("p", _a(["a", "\"b\""]), "blat \n ")])]);
   }
   void test_parse_content_none() {
     ht.HtmlUnit htmlUnit = parse("<html><p/>blat<p/></html>");
     _validate(
         htmlUnit,
-        [_t3("html", "<p/>blat<p/>", [_t3("p", "", []), _t3("p", "", [])])]);
+        [_t3("html", "<p/>blat<p/>", [_t3("p", ""), _t3("p", "")])]);
   }
   void test_parse_declaration() {
     ht.HtmlUnit htmlUnit = parse("<!DOCTYPE html>\n\n<html><p></p></html>");
-    _validate(htmlUnit, [_t4("html", [_t3("p", "", [])])]);
+    _validate(htmlUnit, [_t4("html", [_t3("p", "")])]);
   }
   void test_parse_directive() {
     ht.HtmlUnit htmlUnit = parse("<?xml ?>\n\n<html><p></p></html>");
-    _validate(htmlUnit, [_t4("html", [_t3("p", "", [])])]);
+    _validate(htmlUnit, [_t4("html", [_t3("p", "")])]);
   }
   void test_parse_getAttribute() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsdf\"></body></html>");
     ht.XmlTagNode htmlNode = htmlUnit.tagNodes[0];
     ht.XmlTagNode bodyNode = htmlNode.tagNodes[0];
     expect(bodyNode.getAttribute("foo").text, "sdfsdf");
     expect(bodyNode.getAttribute("bar"), null);
     expect(bodyNode.getAttribute(null), null);
   }
   void test_parse_getAttributeText() {
@@ skipping 10 matching lines @@
   <body>
     <h2>000</h2>
     <div>
       111
     </div>
   </body>
 </html>''';
     ht.HtmlUnit htmlUnit = parse(code);
     _validate(
         htmlUnit,
-        [_t4("html", [_t4("body", [_t3("h2", "000", []), _t4("div", [])])])]);
+        [_t4("html", [_t4("body", [_t3("h2", "000"), _t4("div")])])]);
   }
   void test_parse_script() {
     ht.HtmlUnit htmlUnit =
         parse("<html><script >here is <p> some</script></html>");
-    _validate(htmlUnit, [_t4("html", [_t3("script", "here is <p> some", [])])]);
+    _validate(htmlUnit, [_t4("html", [_t3("script", "here is <p> some")])]);
   }
   void test_parse_self_closing() {
     ht.HtmlUnit htmlUnit = parse("<html>foo<br>bar</html>");
-    _validate(htmlUnit, [_t3("html", "foo<br>bar", [_t3("br", "", [])])]);
+    _validate(htmlUnit, [_t3("html", "foo<br>bar", [_t3("br", "")])]);
   }
   void test_parse_self_closing_declaration() {
     ht.HtmlUnit htmlUnit = parse("<!DOCTYPE html><html>foo</html>");
-    _validate(htmlUnit, [_t3("html", "foo", [])]);
+    _validate(htmlUnit, [_t3("html", "foo")]);
   }
   XmlValidator_Attributes _a(List<String> keyValuePairs) =>
       new XmlValidator_Attributes(keyValuePairs);
   XmlValidator_Tag _t(String tag, XmlValidator_Attributes attributes,
-      String content, List<XmlValidator_Tag> children) =>
+      String content, [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
       new XmlValidator_Tag(tag, attributes, content, children);
   XmlValidator_Tag _t2(String tag, XmlValidator_Attributes attributes,
-      List<XmlValidator_Tag> children) =>
+      [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
       new XmlValidator_Tag(tag, attributes, null, children);
   XmlValidator_Tag _t3(String tag, String content,
-      List<XmlValidator_Tag> children) =>
-      new XmlValidator_Tag(tag, new XmlValidator_Attributes([]), content, children);
-  XmlValidator_Tag _t4(String tag, List<XmlValidator_Tag> children) =>
-      new XmlValidator_Tag(tag, new XmlValidator_Attributes([]), null, children);
+      [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
+      new XmlValidator_Tag(tag, new XmlValidator_Attributes(), content, children);
+  XmlValidator_Tag _t4(String tag, [List<XmlValidator_Tag> children = XmlValidator_Tag.EMPTY_LIST]) =>
+      new XmlValidator_Tag(tag, new XmlValidator_Attributes(), null, children);
   void _validate(ht.HtmlUnit htmlUnit, List<XmlValidator_Tag> expectedTags) {
     XmlValidator validator = new XmlValidator();
     validator.expectTags(expectedTags);
     htmlUnit.accept(validator);
     validator.assertValid();
   }
 }
 
 
 class HtmlTagInfoBuilderTest extends HtmlParserTest {
@@ skipping 35 matching lines @@
 <html>
 <script type="application/dart">foo=2;</script>
 </html>''');
     _validate(element, [_s(_l([_v("foo")]))]);
   }
   void test_embedded_script_no_content() {
     HtmlElementImpl element = _build(r'''
 <html>
 <script type="application/dart"></script>
 </html>''');
-    _validate(element, [_s(_l([]))]);
+    _validate(element, [_s(_l())]);
   }
   void test_external_script() {
     HtmlElementImpl element = _build(r'''
 <html>
 <script type="application/dart" src="other.dart"/>
 </html>''');
     _validate(element, [_s2("other.dart")]);
   }
   void test_external_script_no_source() {
     HtmlElementImpl element = _build(r'''
@@ skipping 31 matching lines @@
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     HtmlUnitBuilder builder = new HtmlUnitBuilder(_context);
     return builder.buildHtmlElement(
         source,
         _context.getModificationStamp(source),
         _context.parseHtmlUnit(source));
   }
   HtmlUnitBuilderTest_ExpectedLibrary
-      _l(List<HtmlUnitBuilderTest_ExpectedVariable> expectedVariables) =>
+      _l([List<HtmlUnitBuilderTest_ExpectedVariable> expectedVariables = HtmlUnitBuilderTest_ExpectedVariable.EMPTY_LIST]) =>
       new HtmlUnitBuilderTest_ExpectedLibrary(this, expectedVariables);
   _ExpectedScript _s(HtmlUnitBuilderTest_ExpectedLibrary expectedLibrary) =>
       new _ExpectedScript.con1(expectedLibrary);
   _ExpectedScript _s2(String scriptSourcePath) =>
       new _ExpectedScript.con2(scriptSourcePath);
   HtmlUnitBuilderTest_ExpectedVariable _v(String varName) =>
       new HtmlUnitBuilderTest_ExpectedVariable(varName);
   void _validate(HtmlElementImpl element,
       List<_ExpectedScript> expectedScripts) {
     expect(element.context, same(_context));
     List<HtmlScriptElement> scripts = element.scripts;
     expect(scripts, isNotNull);
     expect(scripts, hasLength(expectedScripts.length));
     for (int scriptIndex = 0; scriptIndex < scripts.length; scriptIndex++) {
       expectedScripts[scriptIndex]._validate(scriptIndex, scripts[scriptIndex]);
     }
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedLibrary {
   final HtmlUnitBuilderTest HtmlUnitBuilderTest_this;
   final List<HtmlUnitBuilderTest_ExpectedVariable> _expectedVariables;
   HtmlUnitBuilderTest_ExpectedLibrary(this.HtmlUnitBuilderTest_this,
-      this._expectedVariables);
+      [this._expectedVariables = HtmlUnitBuilderTest_ExpectedVariable.EMPTY_LIST]);
   void _validate(int scriptIndex, EmbeddedHtmlScriptElementImpl script) {
     LibraryElement library = script.scriptLibrary;
     expect(library, isNotNull, reason: "script $scriptIndex");
     expect(script.context, same(HtmlUnitBuilderTest_this._context), reason: "script $scriptIndex");
     CompilationUnitElement unit = library.definingCompilationUnit;
     expect(unit, isNotNull, reason: "script $scriptIndex");
     List<TopLevelVariableElement> variables = unit.topLevelVariables;
     expect(variables, hasLength(_expectedVariables.length));
     for (int index = 0; index < variables.length; index++) {
       _expectedVariables[index].validate(scriptIndex, variables[index]);
     }
     expect(library.enclosingElement, same(script), reason: "script $scriptIndex");
   }
 }
 
 
 class HtmlUnitBuilderTest_ExpectedVariable {
   final String _expectedName;
+  static const List<HtmlUnitBuilderTest_ExpectedVariable> EMPTY_LIST
+      = const <HtmlUnitBuilderTest_ExpectedVariable>[];
   HtmlUnitBuilderTest_ExpectedVariable(this._expectedName);
   void validate(int scriptIndex, TopLevelVariableElement variable) {
     expect(variable, isNotNull, reason: "script $scriptIndex");
     expect(variable.name, _expectedName, reason: "script $scriptIndex");
   }
 }
 
 
 /**
  * Instances of the class `HtmlWarningCodeTest` test the generation of HTML warning codes.
@@ skipping 171 matching lines @@
   void test_visitSuperConstructorInvocation_nonConst() {
     _visitNode(_makeTailSuperConstructorInvocation("A", false, true));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_notInMap() {
     _visitNode(_makeTailSuperConstructorInvocation("A", true, false));
     _assertNoArcs();
   }
   void test_visitSuperConstructorInvocation_unresolved() {
     SuperConstructorInvocation superConstructorInvocation =
-        AstFactory.superConstructorInvocation([]);
+        AstFactory.superConstructorInvocation();
     _tail = superConstructorInvocation;
     _visitNode(superConstructorInvocation);
     _assertNoArcs();
   }
   void _assertNoArcs() {
     Set<AstNode> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(0));
   }
   void _assertOneArc(AstNode tail) {
     Set<AstNode> tails = _referenceGraph.getTails(_head);
     expect(tails, hasLength(1));
     expect(tails.first, same(tail));
   }
   ReferenceFinder _createReferenceFinder(AstNode source) =>
       new ReferenceFinder(
           source,
           _referenceGraph,
           _variableDeclarationMap,
           _constructorDeclarationMap);
   InstanceCreationExpression _makeTailConstructor(String name,
       bool isConstDeclaration, bool isConstUsage, bool inMap) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration(
             AstFactory.identifier3(name),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             initializers);
     if (isConstDeclaration) {
       constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
     }
-    ClassElementImpl classElement = ElementFactory.classElement2(name, []);
+    ClassElementImpl classElement = ElementFactory.classElement2(name);
     SimpleIdentifier identifier = AstFactory.identifier3(name);
-    TypeName type = AstFactory.typeName3(identifier, []);
+    TypeName type = AstFactory.typeName3(identifier);
     InstanceCreationExpression instanceCreationExpression =
         AstFactory.instanceCreationExpression2(
             isConstUsage ? Keyword.CONST : Keyword.NEW,
-            type,
-            []);
+            type);
     _tail = instanceCreationExpression;
     ConstructorElementImpl constructorElement =
-        ElementFactory.constructorElement(classElement, name, isConstDeclaration, []);
+        ElementFactory.constructorElement(classElement, name, isConstDeclaration);
     if (inMap) {
       _constructorDeclarationMap[constructorElement] = constructorDeclaration;
     }
     instanceCreationExpression.staticElement = constructorElement;
     return instanceCreationExpression;
   }
   SuperConstructorInvocation _makeTailSuperConstructorInvocation(String name,
       bool isConst, bool inMap) {
     List<ConstructorInitializer> initializers =
         new List<ConstructorInitializer>();
     ConstructorDeclaration constructorDeclaration =
         AstFactory.constructorDeclaration(
             AstFactory.identifier3(name),
             null,
-            AstFactory.formalParameterList([]),
+            AstFactory.formalParameterList(),
             initializers);
     _tail = constructorDeclaration;
     if (isConst) {
       constructorDeclaration.constKeyword = new KeywordToken(Keyword.CONST, 0);
     }
-    ClassElementImpl classElement = ElementFactory.classElement2(name, []);
+    ClassElementImpl classElement = ElementFactory.classElement2(name);
     SuperConstructorInvocation superConstructorInvocation =
-        AstFactory.superConstructorInvocation([]);
+        AstFactory.superConstructorInvocation();
     ConstructorElementImpl constructorElement =
-        ElementFactory.constructorElement(classElement, name, isConst, []);
+        ElementFactory.constructorElement(classElement, name, isConst);
     if (inMap) {
       _constructorDeclarationMap[constructorElement] = constructorDeclaration;
     }
     superConstructorInvocation.staticElement = constructorElement;
     return superConstructorInvocation;
   }
   SimpleIdentifier _makeTailVariable(String name, bool isConst, bool inMap) {
     VariableDeclaration variableDeclaration =
         AstFactory.variableDeclaration(name);
     _tail = variableDeclaration;
@@ skipping 171 matching lines @@
     _assertSource(
         "<script type='application/dart'>f() {}</script>",
         HtmlFactory.scriptTagWithContent(
             "f() {}",
             [HtmlFactory.attribute("type", "'application/dart'")]));
   }
 
   void fail_visitHtmlScriptTagNode_noAttributes_content() {
     _assertSource(
         "<script>f() {}</script>",
-        HtmlFactory.scriptTagWithContent("f() {}", []));
+        HtmlFactory.scriptTagWithContent("f() {}"));
   }
 
   void test_visitHtmlScriptTagNode_attributes_noContent() {
     _assertSource(
         "<script type='application/dart'/>",
         HtmlFactory.scriptTag([HtmlFactory.attribute("type", "'application/dart'")]));
   }
 
   void test_visitHtmlScriptTagNode_noAttributes_noContent() {
-    _assertSource("<script/>", HtmlFactory.scriptTag([]));
+    _assertSource("<script/>", HtmlFactory.scriptTag());
   }
 
   void test_visitHtmlUnit_empty() {
     _assertSource("", new ht.HtmlUnit(null, new List<ht.XmlTagNode>(), null));
   }
 
   void test_visitHtmlUnit_nonEmpty() {
     _assertSource(
         "<html/>",
-        new ht.HtmlUnit(null, [HtmlFactory.tagNode("html", [])], null));
+        new ht.HtmlUnit(null, [HtmlFactory.tagNode("html")], null));
   }
 
   void test_visitXmlAttributeNode() {
     _assertSource("x=y", HtmlFactory.attribute("x", "y"));
   }
 
   /**
    * Assert that a `ToSourceVisitor` will produce the expected source when visiting the given
    * node.
    *
@@ skipping 360 matching lines @@
         _errors.add(
             "Invalid source end ($nodeEnd) for ${node.runtimeType} inside ${parent.runtimeType} ($parentStart)");
       }
     }
   }
 }
 
 
 class XmlValidator_Attributes {
   final List<String> _keyValuePairs;
-  XmlValidator_Attributes(this._keyValuePairs);
+  XmlValidator_Attributes([this._keyValuePairs = StringUtilities.EMPTY_ARRAY]);
 }
 
 
 class XmlValidator_Tag {
   final String _tag;
   final XmlValidator_Attributes _attributes;
   final String _content;
   final List<XmlValidator_Tag> _children;
-  XmlValidator_Tag(this._tag, this._attributes, this._content, this._children);
+  static const List<XmlValidator_Tag> EMPTY_LIST = const <XmlValidator_Tag>[];
+  XmlValidator_Tag(this._tag, this._attributes, this._content, [this._children = EMPTY_LIST]);
 }
 
 
 class _AngularTest_findElement extends GeneralizingElementVisitor<Object> {
   final ElementKind kind;
 
   final String name;
 
   Element result;
 
@@ skipping 44 matching lines @@
     Source scriptSource = externalScript.scriptSource;
     if (_expectedExternalScriptName == null) {
       expect(scriptSource, isNull, reason: "script $scriptIndex");
     } else {
       expect(scriptSource, isNotNull, reason: "script $scriptIndex");
       String actualExternalScriptName = scriptSource.shortName;
       expect(actualExternalScriptName, _expectedExternalScriptName, reason: "script $scriptIndex");
     }
   }
 }