Create fewer unnecessary lists

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
@@ skipping 70 matching lines @@
     context.sourceFactory = sourceFactory;
     AnalysisContext coreContext = sdk.context;
     //
     // dart:core
     //
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     coreContext.setContents(coreSource, "");
     coreUnit.source = coreSource;
-    ClassElementImpl proxyClassElement = ElementFactory.classElement2("_Proxy", []);
+    ClassElementImpl proxyClassElement = ElementFactory.classElement2("_Proxy");
     coreUnit.types = <ClassElement> [
         provider.boolType.element,
         provider.deprecatedType.element,
         provider.doubleType.element,
         provider.functionType.element,
         provider.intType.element,
         provider.listType.element,
         provider.mapType.element,
         provider.nullType.element,
         provider.numType.element,
@@ skipping 18 matching lines @@
     // dart:async
     //
     CompilationUnitElementImpl asyncUnit = new CompilationUnitElementImpl("async.dart");
     Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
     coreContext.setContents(asyncSource, "");
     asyncUnit.source = asyncSource;
     // Future
     ClassElementImpl futureElement = ElementFactory.classElement2("Future", ["T"]);
     InterfaceType futureType = futureElement.type;
     //   factory Future.value([value])
-    ConstructorElementImpl futureConstructor = ElementFactory.constructorElement2(futureElement, "value", []);
+    ConstructorElementImpl futureConstructor = ElementFactory.constructorElement2(futureElement, "value");
     futureConstructor.parameters = <ParameterElement> [ElementFactory.positionalParameter2("value", provider.dynamicType)];
     futureConstructor.factory = true;
     (futureConstructor.type as FunctionTypeImpl).typeArguments = futureElement.type.typeArguments;
     futureElement.constructors = <ConstructorElement> [futureConstructor];
     //   Future then(onValue(T value), { Function onError });
     List<ParameterElement> parameters = <ParameterElement> [ElementFactory.requiredParameter2("value", futureElement.typeParameters[0].type)];
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl.forNode(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
     aliasElement.returnType = provider.dynamicType;
     FunctionTypeImpl aliasType = new FunctionTypeImpl.con2(aliasElement);
     aliasElement.shareTypeParameters(futureElement.typeParameters);
     aliasType.typeArguments = futureElement.type.typeArguments;
     MethodElement thenMethod = ElementFactory.methodElementWithParameters("then", futureElement.type.typeArguments, futureType, [
         ElementFactory.requiredParameter2("onValue", aliasType),
         ElementFactory.namedParameter2("onError", provider.functionType)]);
     futureElement.methods = <MethodElement> [thenMethod];
     // Completer
     ClassElementImpl completerElement = ElementFactory.classElement2("Completer", ["T"]);
-    ConstructorElementImpl completerConstructor = ElementFactory.constructorElement2(completerElement, null, []);
+    ConstructorElementImpl completerConstructor = ElementFactory.constructorElement2(completerElement, null);
     (completerConstructor.type as FunctionTypeImpl).typeArguments = completerElement.type.typeArguments;
     completerElement.constructors = <ConstructorElement> [completerConstructor];
     asyncUnit.types = <ClassElement> [
         completerElement,
         futureElement,
         ElementFactory.classElement2("Stream", ["T"])];
     LibraryElementImpl asyncLibrary = new LibraryElementImpl.forNode(coreContext, AstFactory.libraryIdentifier2(["dart", "async"]));
     asyncLibrary.definingCompilationUnit = asyncUnit;
     //
     // dart:html
     //
     CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
     Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
     coreContext.setContents(htmlSource, "");
     htmlUnit.source = htmlSource;
-    ClassElementImpl elementElement = ElementFactory.classElement2("Element", []);
+    ClassElementImpl elementElement = ElementFactory.classElement2("Element");
     InterfaceType elementType = elementElement.type;
-    ClassElementImpl canvasElement = ElementFactory.classElement("CanvasElement", elementType, []);
-    ClassElementImpl contextElement = ElementFactory.classElement2("CanvasRenderingContext", []);
+    ClassElementImpl canvasElement = ElementFactory.classElement("CanvasElement", elementType);
+    ClassElementImpl contextElement = ElementFactory.classElement2("CanvasRenderingContext");
     InterfaceType contextElementType = contextElement.type;
-    ClassElementImpl context2dElement = ElementFactory.classElement("CanvasRenderingContext2D", contextElementType, []);
+    ClassElementImpl context2dElement = ElementFactory.classElement("CanvasRenderingContext2D", contextElementType);
     canvasElement.methods = <MethodElement> [ElementFactory.methodElement("getContext", contextElementType, [provider.stringType])];
     canvasElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("context2D", false, context2dElement.type)];
-    ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType, []);
-    ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type, []);
+    ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType);
+    ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type);
     htmlDocumentElement.methods = <MethodElement> [ElementFactory.methodElement("query", elementType, <DartType> [provider.stringType])];
     htmlUnit.types = <ClassElement> [
-        ElementFactory.classElement("AnchorElement", elementType, []),
-        ElementFactory.classElement("BodyElement", elementType, []),
-        ElementFactory.classElement("ButtonElement", elementType, []),
+        ElementFactory.classElement("AnchorElement", elementType),
+        ElementFactory.classElement("BodyElement", elementType),
+        ElementFactory.classElement("ButtonElement", elementType),
         canvasElement,
         contextElement,
         context2dElement,
-        ElementFactory.classElement("DivElement", elementType, []),
+        ElementFactory.classElement("DivElement", elementType),
         documentElement,
         elementElement,
         htmlDocumentElement,
-        ElementFactory.classElement("InputElement", elementType, []),
-        ElementFactory.classElement("SelectElement", elementType, [])];
+        ElementFactory.classElement("InputElement", elementType),
+        ElementFactory.classElement("SelectElement", elementType)];
     htmlUnit.functions = <FunctionElement> [ElementFactory.functionElement3("query", elementElement, <ClassElement> [provider.stringType.element], ClassElementImpl.EMPTY_ARRAY)];
     TopLevelVariableElementImpl document = ElementFactory.topLevelVariableElement3("document", false, true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement> [document];
     htmlUnit.accessors = <PropertyAccessorElement> [document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl.forNode(coreContext, AstFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     //
     // dart:math
     //
     CompilationUnitElementImpl mathUnit = new CompilationUnitElementImpl("math.dart");
     Source mathSource = sourceFactory.forUri(_DART_MATH);
     coreContext.setContents(mathSource, "");
     mathUnit.source = mathSource;
-    FunctionElement cosElement = ElementFactory.functionElement3("cos", provider.doubleType.element, <ClassElement> [provider.numType.element], <ClassElement> []);
+    FunctionElement cosElement = ElementFactory.functionElement3("cos", provider.doubleType.element, <ClassElement>[provider.numType.element], ClassElementImpl.EMPTY_ARRAY);
     TopLevelVariableElement ln10Element = ElementFactory.topLevelVariableElement3("LN10", true, false, provider.doubleType);
     TopLevelVariableElement piElement = ElementFactory.topLevelVariableElement3("PI", true, false, provider.doubleType);
-    ClassElementImpl randomElement = ElementFactory.classElement2("Random", []);
+    ClassElementImpl randomElement = ElementFactory.classElement2("Random");
     randomElement.abstract = true;
-    ConstructorElementImpl randomConstructor = ElementFactory.constructorElement2(randomElement, null, []);
+    ConstructorElementImpl randomConstructor = ElementFactory.constructorElement2(randomElement, null);
     randomConstructor.factory = true;
     ParameterElementImpl seedParam = new ParameterElementImpl("seed", 0);
     seedParam.parameterKind = ParameterKind.POSITIONAL;
     seedParam.type = provider.intType;
     randomConstructor.parameters = <ParameterElement> [seedParam];
     randomElement.constructors = <ConstructorElement> [randomConstructor];
-    FunctionElement sinElement = ElementFactory.functionElement3("sin", provider.doubleType.element, <ClassElement> [provider.numType.element], <ClassElement> []);
-    FunctionElement sqrtElement = ElementFactory.functionElement3("sqrt", provider.doubleType.element, <ClassElement> [provider.numType.element], <ClassElement> []);
+    FunctionElement sinElement = ElementFactory.functionElement3("sin", provider.doubleType.element, <ClassElement> [provider.numType.element], ClassElementImpl.EMPTY_ARRAY);
+    FunctionElement sqrtElement = ElementFactory.functionElement3("sqrt", provider.doubleType.element, <ClassElement> [provider.numType.element], ClassElementImpl.EMPTY_ARRAY);
     mathUnit.accessors = <PropertyAccessorElement> [ln10Element.getter, piElement.getter];
     mathUnit.functions = <FunctionElement> [cosElement, sinElement, sqrtElement];
     mathUnit.topLevelVariables = <TopLevelVariableElement> [ln10Element, piElement];
     mathUnit.types = <ClassElement> [randomElement];
     LibraryElementImpl mathLibrary = new LibraryElementImpl.forNode(coreContext, AstFactory.libraryIdentifier2(["dart", "math"]));
     mathLibrary.definingCompilationUnit = mathUnit;
     //
     // Set empty sources for the rest of the libraries.
     //
     Source source = sourceFactory.forUri(_DART_INTERCEPTORS);
@@ skipping 832 matching lines @@
     return p + p;
   }
 }''';
     _assertMethodMatches(true, content, content);
   }
 
   void _assertCompilationUnitMatches(bool expectMatch, String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
-    CompilationUnit newUnit = ParserTestCase.parseCompilationUnit(newContent, []);
+    CompilationUnit newUnit = ParserTestCase.parseCompilationUnit(newContent);
     DeclarationMatcher matcher = new DeclarationMatcher();
     expect(matcher.matches(newUnit, oldUnit.element), expectMatch);
   }
 
   void _assertMethodMatches(bool expectMatch, String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
     MethodElement element = _getFirstMethod(oldUnit).element as MethodElement;
     AnalysisContext context = analysisContext;
@@ skipping 58 matching lines @@
 
   /**
    * The resolver being used to resolve the test cases.
    */
   ElementResolver _resolver;
 
   void fail_visitExportDirective_combinators() {
     fail("Not yet tested");
     // Need to set up the exported library so that the identifier can be resolved
     ExportDirective directive = AstFactory.exportDirective2(null, [AstFactory.hideCombinator2(["A"])]);
-    _resolveNode(directive, []);
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionExpressionInvocation() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_noPrefix() {
     fail("Not yet tested");
     // Need to set up the imported library so that the identifier can be resolved
     ImportDirective directive = AstFactory.importDirective3(null, null, [AstFactory.showCombinator2(["A"])]);
-    _resolveNode(directive, []);
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_prefix() {
     fail("Not yet tested");
     // Need to set up the imported library so that the identifiers can be resolved
     String prefixName = "p";
-    _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, ElementFactory.prefix(prefixName), [])];
+    _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, ElementFactory.prefix(prefixName))];
     ImportDirective directive = AstFactory.importDirective3(null, prefixName, [
         AstFactory.showCombinator2(["A"]),
         AstFactory.hideCombinator2(["B"])]);
-    _resolveNode(directive, []);
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void fail_visitRedirectingConstructorInvocation() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = _createResolver();
   }
 
   void test_lookUpMethodInInterfaces() {
     InterfaceType intType = _typeProvider.intType;
     //
     // abstract class A { int operator[](int index); }
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     MethodElement operator = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [operator];
     //
     // class B implements A {}
     //
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     //
     // class C extends Object with B {}
     //
-    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    ClassElementImpl classC = ElementFactory.classElement2("C");
     classC.mixins = <InterfaceType> [classB.type];
     //
     // class D extends C {}
     //
-    ClassElementImpl classD = ElementFactory.classElement("D", classC.type, []);
+    ClassElementImpl classD = ElementFactory.classElement("D", classC.type);
     //
     // D a;
     // a[i];
     //
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classD.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
-    expect(_resolveIndexExpression(expression, []), same(operator));
+    expect(_resolveIndexExpression(expression), same(operator));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
     InterfaceType intType = _typeProvider.intType;
     SimpleIdentifier leftHandSide = AstFactory.identifier3("a");
     leftHandSide.staticType = intType;
     AssignmentExpression assignment = AstFactory.assignmentExpression(leftHandSide, TokenType.PLUS_EQ, AstFactory.integer(1));
-    _resolveNode(assignment, []);
+    _resolveNode(assignment);
     expect(assignment.staticElement, same(getMethod(_typeProvider.numType, "+")));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_simple() {
     AssignmentExpression expression = AstFactory.assignmentExpression(AstFactory.identifier3("x"), TokenType.EQ, AstFactory.integer(0));
-    _resolveNode(expression, []);
+    _resolveNode(expression);
     expect(expression.staticElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression() {
     // num i;
     // var j;
     // i + j
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = numType;
     BinaryExpression expression = AstFactory.binaryExpression(left, TokenType.PLUS, AstFactory.identifier3("j"));
-    _resolveNode(expression, []);
+    _resolveNode(expression);
     expect(expression.staticElement, getMethod(numType, "+"));
     expect(expression.propagatedElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_propagatedElement() {
     // var i = 1;
     // var j;
     // i + j
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.propagatedType = numType;
     BinaryExpression expression = AstFactory.binaryExpression(left, TokenType.PLUS, AstFactory.identifier3("j"));
-    _resolveNode(expression, []);
+    _resolveNode(expression);
     expect(expression.staticElement, isNull);
     expect(expression.propagatedElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(AstFactory.identifier3(label), false, false);
     BreakStatement statement = AstFactory.breakStatement2(label);
     expect(_resolveBreak(statement, labelElement), same(labelElement));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withoutLabel() {
     BreakStatement statement = AstFactory.breakStatement();
     _resolveStatement(statement, null);
     _listener.assertNoErrors();
   }
 
   void test_visitConstructorName_named() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = "a";
-    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
+    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement> [constructor];
-    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
-    _resolveNode(name, []);
+    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
+    _resolveNode(name);
     expect(name.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitConstructorName_unnamed() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = null;
-    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
+    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement> [constructor];
-    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
-    _resolveNode(name, []);
+    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
+    _resolveNode(name);
     expect(name.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(AstFactory.identifier3(label), false, false);
     ContinueStatement statement = AstFactory.continueStatement(label);
     expect(_resolveContinue(statement, labelElement), same(labelElement));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withoutLabel() {
     ContinueStatement statement = AstFactory.continueStatement();
     _resolveStatement(statement, null);
     _listener.assertNoErrors();
   }
 
   void test_visitExportDirective_noCombinators() {
-    ExportDirective directive = AstFactory.exportDirective2(null, []);
-    directive.element = ElementFactory.exportFor(ElementFactory.library(_definingLibrary.context, "lib"), []);
-    _resolveNode(directive, []);
+    ExportDirective directive = AstFactory.exportDirective2(null);
+    directive.element = ElementFactory.exportFor(ElementFactory.library(_definingLibrary.context, "lib"));
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter() {
     String fieldName = "f";
     InterfaceType intType = _typeProvider.intType;
     FieldElementImpl fieldElement = ElementFactory.fieldElement(fieldName, false, false, false, intType);
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.fields = <FieldElement> [fieldElement];
     FieldFormalParameter parameter = AstFactory.fieldFormalParameter2(fieldName);
     FieldFormalParameterElementImpl parameterElement = ElementFactory.fieldFormalParameter(parameter.identifier);
     parameterElement.field = fieldElement;
     parameterElement.type = intType;
     parameter.identifier.staticElement = parameterElement;
     _resolveInClass(parameter, classA);
     expect(parameter.element.type, same(intType));
   }
 
   void test_visitImportDirective_noCombinators_noPrefix() {
-    ImportDirective directive = AstFactory.importDirective3(null, null, []);
-    directive.element = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), null, []);
-    _resolveNode(directive, []);
+    ImportDirective directive = AstFactory.importDirective3(null, null);
+    directive.element = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), null);
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void test_visitImportDirective_noCombinators_prefix() {
     String prefixName = "p";
-    ImportElement importElement = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), ElementFactory.prefix(prefixName), []);
+    ImportElement importElement = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), ElementFactory.prefix(prefixName));
     _definingLibrary.imports = <ImportElement> [importElement];
-    ImportDirective directive = AstFactory.importDirective3(null, prefixName, []);
+    ImportDirective directive = AstFactory.importDirective3(null, prefixName);
     directive.element = importElement;
-    _resolveNode(directive, []);
+    _resolveNode(directive);
     _listener.assertNoErrors();
   }
 
   void test_visitImportDirective_withCombinators() {
     ShowCombinator combinator = AstFactory.showCombinator2(["A", "B", "C"]);
     ImportDirective directive = AstFactory.importDirective3(null, null, [combinator]);
     LibraryElementImpl library = ElementFactory.library(_definingLibrary.context, "lib");
     TopLevelVariableElementImpl varA = ElementFactory.topLevelVariableElement2("A");
     TopLevelVariableElementImpl varB = ElementFactory.topLevelVariableElement2("B");
     TopLevelVariableElementImpl varC = ElementFactory.topLevelVariableElement2("C");
     CompilationUnitElementImpl unit = library.definingCompilationUnit as CompilationUnitElementImpl;
     unit.accessors = <PropertyAccessorElement> [varA.getter, varA.setter, varB.getter, varC.setter];
     unit.topLevelVariables = <TopLevelVariableElement> [varA, varB, varC];
-    directive.element = ElementFactory.importFor(library, null, []);
-    _resolveNode(directive, []);
+    directive.element = ElementFactory.importFor(library, null);
+    _resolveNode(directive);
     expect(combinator.shownNames[0].staticElement, same(varA));
     expect(combinator.shownNames[1].staticElement, same(varB));
     expect(combinator.shownNames[2].staticElement, same(varC));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_get() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     InterfaceType intType = _typeProvider.intType;
     MethodElement getter = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [getter];
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
-    expect(_resolveIndexExpression(expression, []), same(getter));
+    expect(_resolveIndexExpression(expression), same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_set() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     InterfaceType intType = _typeProvider.intType;
     MethodElement setter = ElementFactory.methodElement("[]=", intType, [intType]);
     classA.methods = <MethodElement> [setter];
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
     AstFactory.assignmentExpression(expression, TokenType.EQ, AstFactory.integer(0));
-    expect(_resolveIndexExpression(expression, []), same(setter));
+    expect(_resolveIndexExpression(expression), same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_named() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = "a";
-    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
+    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement> [constructor];
-    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
+    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
     name.staticElement = constructor;
-    InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, []);
-    _resolveNode(creation, []);
+    InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name);
+    _resolveNode(creation);
     expect(creation.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = null;
-    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
+    ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName);
     classA.constructors = <ConstructorElement> [constructor];
-    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
+    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
     name.staticElement = constructor;
-    InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, []);
-    _resolveNode(creation, []);
+    InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name);
+    _resolveNode(creation);
     expect(creation.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed_namedParameter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String constructorName = null;
-    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classA, constructorName, []);
+    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classA, constructorName);
     String parameterName = "a";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     constructor.parameters = <ParameterElement> [parameter];
     classA.constructors = <ConstructorElement> [constructor];
-    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
+    ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
-    _resolveNode(creation, []);
+    _resolveNode(creation);
     expect(creation.staticElement, same(constructor));
     expect((creation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = numType;
     String methodName = "abs";
-    MethodInvocation invocation = AstFactory.methodInvocation(left, methodName, []);
-    _resolveNode(invocation, []);
+    MethodInvocation invocation = AstFactory.methodInvocation(left, methodName);
+    _resolveNode(invocation);
     expect(invocation.methodName.staticElement, same(getMethod(numType, methodName)));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_namedParameter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
     String parameterName = "p";
-    MethodElementImpl method = ElementFactory.methodElement(methodName, null, []);
+    MethodElementImpl method = ElementFactory.methodElement(methodName, null);
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     method.parameters = <ParameterElement> [parameter];
     classA.methods = <MethodElement> [method];
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = classA.type;
     MethodInvocation invocation = AstFactory.methodInvocation(left, methodName, [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
-    _resolveNode(invocation, []);
+    _resolveNode(invocation);
     expect(invocation.methodName.staticElement, same(method));
     expect((invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PostfixExpression expression = AstFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
-    _resolveNode(expression, []);
+    _resolveNode(expression);
     expect(expression.staticElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_dynamic() {
     DartType dynamicType = _typeProvider.dynamicType;
     SimpleIdentifier target = AstFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = dynamicType;
     target.staticElement = variable;
     target.staticType = dynamicType;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3("b"));
-    _resolveNode(identifier, []);
+    _resolveNode(identifier);
     expect(identifier.staticElement, isNull);
     expect(identifier.identifier.staticElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_nonDynamic() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = AstFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = classA.type;
     target.staticElement = variable;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(getterName));
-    _resolveNode(identifier, []);
+    _resolveNode(identifier);
     expect(identifier.staticElement, same(getter));
     expect(identifier.identifier.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_getter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
     // prepare "A.m"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     // resolve
-    _resolveNode(identifier, []);
+    _resolveNode(identifier);
     expect(identifier.staticElement, same(getter));
     expect(identifier.identifier.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_method() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     // set accessors
     String propName = "m";
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setter];
     // set methods
-    MethodElement method = ElementFactory.methodElement("m", _typeProvider.intType, []);
+    MethodElement method = ElementFactory.methodElement("m", _typeProvider.intType);
     classA.methods = <MethodElement> [method];
     // prepare "A.m"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     AstFactory.assignmentExpression(identifier, TokenType.EQ, AstFactory.nullLiteral());
     // resolve
-    _resolveNode(identifier, []);
+    _resolveNode(identifier);
     expect(identifier.staticElement, same(method));
     expect(identifier.identifier.staticElement, same(method));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_setter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
     // prepare "A.b = null"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     AstFactory.assignmentExpression(identifier, TokenType.EQ, AstFactory.nullLiteral());
     // resolve
-    _resolveNode(identifier, []);
+    _resolveNode(identifier);
     expect(identifier.staticElement, same(setter));
     expect(identifier.identifier.staticElement, same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PrefixExpression expression = AstFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
-    _resolveNode(expression, []);
+    _resolveNode(expression);
     expect(expression.staticElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter_identifier() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = AstFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
-    _resolveNode(access, []);
+    _resolveNode(access);
     expect(access.propertyName.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter_super() {
     //
     // class A {
     //  int get b;
     // }
     // class B {
     //   ... super.m ...
     // }
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SuperExpression target = AstFactory.superExpression();
-    target.staticType = ElementFactory.classElement("B", classA.type, []).type;
+    target.staticType = ElementFactory.classElement("B", classA.type).type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
-    AstFactory.methodDeclaration2(null, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList([]), AstFactory.expressionFunctionBody(access));
-    _resolveNode(access, []);
+    AstFactory.methodDeclaration2(null, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList(), AstFactory.expressionFunctionBody(access));
+    _resolveNode(access);
     expect(access.propertyName.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_setter_this() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "b";
     PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setter];
     ThisExpression target = AstFactory.thisExpression();
     target.staticType = classA.type;
     PropertyAccess access = AstFactory.propertyAccess2(target, setterName);
     AstFactory.assignmentExpression(access, TokenType.EQ, AstFactory.integer(0));
-    _resolveNode(access, []);
+    _resolveNode(access);
     expect(access.propertyName.staticElement, same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_classScope() {
     InterfaceType doubleType = _typeProvider.doubleType;
     String fieldName = "NAN";
     SimpleIdentifier node = AstFactory.identifier3(fieldName);
     _resolveInClass(node, doubleType.element);
     expect(node.staticElement, getGetter(doubleType, fieldName));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_dynamic() {
     SimpleIdentifier node = AstFactory.identifier3("dynamic");
-    _resolveIdentifier(node, []);
+    _resolveIdentifier(node);
     expect(node.staticElement, same(_typeProvider.dynamicType.element));
     expect(node.staticType, same(_typeProvider.typeType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_lexicalScope() {
     SimpleIdentifier node = AstFactory.identifier3("i");
     VariableElementImpl element = ElementFactory.localVariableElement(node);
     expect(_resolveIdentifier(node, [element]), same(element));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_lexicalScope_field_setter() {
     InterfaceType intType = _typeProvider.intType;
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String fieldName = "a";
     FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType);
     classA.fields = <FieldElement> [field];
     classA.accessors = <PropertyAccessorElement> [field.getter, field.setter];
     SimpleIdentifier node = AstFactory.identifier3(fieldName);
     AstFactory.assignmentExpression(node, TokenType.EQ, AstFactory.integer(0));
     _resolveInClass(node, classA);
     Element element = node.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement, PropertyAccessorElement, element);
     expect((element as PropertyAccessorElement).isSetter, isTrue);
     _listener.assertNoErrors();
   }
 
   void test_visitSuperConstructorInvocation() {
-    ClassElementImpl superclass = ElementFactory.classElement2("A", []);
-    ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null, []);
+    ClassElementImpl superclass = ElementFactory.classElement2("A");
+    ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null);
     superclass.constructors = <ConstructorElement> [superConstructor];
-    ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
-    ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null, []);
+    ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type);
+    ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null);
     subclass.constructors = <ConstructorElement> [subConstructor];
-    SuperConstructorInvocation invocation = AstFactory.superConstructorInvocation([]);
+    SuperConstructorInvocation invocation = AstFactory.superConstructorInvocation();
     _resolveInClass(invocation, subclass);
     expect(invocation.staticElement, superConstructor);
     _listener.assertNoErrors();
   }
 
   void test_visitSuperConstructorInvocation_namedParameter() {
-    ClassElementImpl superclass = ElementFactory.classElement2("A", []);
-    ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null, []);
+    ClassElementImpl superclass = ElementFactory.classElement2("A");
+    ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null);
     String parameterName = "p";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     superConstructor.parameters = <ParameterElement> [parameter];
     superclass.constructors = <ConstructorElement> [superConstructor];
-    ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
-    ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null, []);
+    ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type);
+    ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = AstFactory.superConstructorInvocation([AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveInClass(invocation, subclass);
     expect(invocation.staticElement, superConstructor);
     expect((invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
@@ skipping 47 matching lines @@
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the element to which the expression was resolved
    */
-  Element _resolveIdentifier(Identifier node, List<Element> definedElements) {
+  Element _resolveIdentifier(Identifier node, [List<Element> definedElements]) {
     _resolveNode(node, definedElements);
     return node.staticElement;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param enclosingClass the element representing the class enclosing the identifier
@@ skipping 18 matching lines @@
 
   /**
    * Return the element associated with the given expression after the resolver has resolved the
    * expression.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the element to which the expression was resolved
    */
-  Element _resolveIndexExpression(IndexExpression node, List<Element> definedElements) {
+  Element _resolveIndexExpression(IndexExpression node, [List<Element> definedElements]) {
     _resolveNode(node, definedElements);
     return node.staticElement;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the element to which the expression was resolved
    */
-  void _resolveNode(AstNode node, List<Element> definedElements) {
+  void _resolveNode(AstNode node, [List<Element> definedElements]) {
     try {
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         EnclosedScope innerScope = new EnclosedScope(outerScope);
-        for (Element element in definedElements) {
-          innerScope.define(element);
+        if (definedElements != null) {
+          for (Element element in definedElements) {
+            innerScope.define(element);
+          }
         }
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.nameScope_J2DAccessor = outerScope;
       }
     } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
@@ skipping 1426 matching lines @@
 
   void test_unusedLocalVariable_isRead_usedArgument() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   var v = 1;
   print(++v);
 }
 print(x) {}''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isRead_usedInvocationTarget() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 class A {
   foo() {}
 }
 main() {
   var a = new A();
   a.foo();
 }
 ''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_isInvoked() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 typedef Foo();
 main() {
   Foo foo;
   foo();
 }''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_exception() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception) {
   }
 }''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_stackTrace() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception, stackTrace) {
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_LOCAL_VARIABLE]);
     verify([source]);
   }
 
   void test_unusedLocalVariable_inCatch_stackTrace_used() {
     enableUnusedLocalVariable = true;
     Source source = addSource(r'''
 main() {
   try {
   } catch (exception, stackTrace) {
     print('exception at $stackTrace');
   }
 }
 print(x) {}''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_assignmentExpression_function() {
     Source source = addSource(r'''
 void f() {}
 class A {
   n() {
     var a;
     a = f();
@@ skipping 129 matching lines @@
   void setUp() {
     _typeProvider = new TestTypeProvider();
     _inheritanceManager = _createInheritanceManager();
     InterfaceType objectType = _typeProvider.objectType;
     _numOfMembersInObject = objectType.methods.length + objectType.accessors.length;
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject);
     expect(mapB.get(getterName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_implicitExtends() {
     // class A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_extends() {
     // class A { int g(); }
     // class B extends A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.supertype = classA.type;
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_implements() {
     // class A { int g(); }
     // class B implements A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject);
     expect(mapB.get(methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_implicitExtends() {
     // class A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_getter_method() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I2, I1 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter = ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement> [getter];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI2.type, classI1.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 = ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElement methodM2 = ElementFactory.methodElement(methodName, null, [_typeProvider.stringType]);
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_method_getter() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter = ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement> [getter];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
     // class I1 { dynamic m(int, [int]); }
     // class I2 { dynamic m(int, int, int); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.REQUIRED;
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a2"));
     parameter2.type = _typeProvider.intType;
     parameter2.parameterKind = ParameterKind.POSITIONAL;
     methodM1.parameters = <ParameterElement> [parameter1, parameter2];
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a3"));
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.REQUIRED;
     ParameterElementImpl parameter4 = new ParameterElementImpl.forNode(AstFactory.identifier3("a4"));
     parameter4.type = _typeProvider.intType;
     parameter4.parameterKind = ParameterKind.REQUIRED;
     ParameterElementImpl parameter5 = new ParameterElementImpl.forNode(AstFactory.identifier3("a5"));
     parameter5.type = _typeProvider.intType;
     parameter5.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement> [parameter3, parameter4, parameter5];
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_str_int() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I2, I1 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 = ElementFactory.methodElement(methodName, null, [_typeProvider.stringType]);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElement methodM2 = ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI2.type, classI1.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_extends() {
     // class A { int g(); }
     // class B extends A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_implements() {
     // class A { int g(); }
     // class B implements A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapB.size, _numOfMembersInObject + 1);
     expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_differentNames() {
     // class I1 { int m1(); }
     // class I2 { int m2(); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName1 = "m1";
-    MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType, []);
+    MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     String methodName2 = "m2";
-    MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType, []);
+    MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType);
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 2);
     expect(mapA.get(methodName1), same(methodM1));
     expect(mapA.get(methodName2), same(methodM2));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_getters() {
     // class I1 { int get g; }
     // class I2 { num get g; }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement> [getter1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter2 = ElementFactory.getterElement(accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement> [getter2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(accessorName, false, _typeProvider.dynamicType);
     expect(mapA.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_methods() {
     // class I1 { dynamic m(int); }
     // class I2 { dynamic m(num); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.REQUIRED;
     methodM1.parameters = <ParameterElement> [parameter1];
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter2.type = _typeProvider.numType;
     parameter2.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement> [parameter2];
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
     expect(mapA.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_setters() {
     // class I1 { set s(int); }
     // class I2 { set s(num); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement> [setter1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement setter2 = ElementFactory.setterElement(accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement> [setter2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory.setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
     expect(mapA.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_getters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { A get g; }
     // class I2 { B get g; }
     // class I3 { C get g; }
     // class D implements I1, I2, I3 {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
+    ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(accessorName, false, classA.type);
     classI1.accessors = <PropertyAccessorElement> [getter1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter2 = ElementFactory.getterElement(accessorName, false, classB.type);
     classI2.accessors = <PropertyAccessorElement> [getter2];
-    ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
+    ClassElementImpl classI3 = ElementFactory.classElement2("I3");
     PropertyAccessorElement getter3 = ElementFactory.getterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement> [getter3];
-    ClassElementImpl classD = ElementFactory.classElement2("D", []);
+    ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(accessorName, false, _typeProvider.dynamicType);
     expect(mapD.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_methods() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { dynamic m(A a); }
     // class I2 { dynamic m(B b); }
     // class I3 { dynamic m(C c); }
     // class D implements I1, I2, I3 {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
+    ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter1.type = classA.type;
     parameter1.parameterKind = ParameterKind.REQUIRED;
     methodM1.parameters = <ParameterElement> [parameter1];
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter2.type = classB.type;
     parameter2.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement> [parameter2];
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
-    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
+    ClassElementImpl classI3 = ElementFactory.classElement2("I3");
+    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter3.type = classC.type;
     parameter3.parameterKind = ParameterKind.REQUIRED;
     methodM3.parameters = <ParameterElement> [parameter3];
     classI3.methods = <MethodElement> [methodM3];
-    ClassElementImpl classD = ElementFactory.classElement2("D", []);
+    ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
     expect(mapD.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_setters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { set s(A); }
     // class I2 { set s(B); }
     // class I3 { set s(C); }
     // class D implements I1, I2, I3 {}
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
+    ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(accessorName, false, classA.type);
     classI1.accessors = <PropertyAccessorElement> [setter1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement setter2 = ElementFactory.setterElement(accessorName, false, classB.type);
     classI2.accessors = <PropertyAccessorElement> [setter2];
-    ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
+    ClassElementImpl classI3 = ElementFactory.classElement2("I3");
     PropertyAccessorElement setter3 = ElementFactory.setterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement> [setter3];
-    ClassElementImpl classD = ElementFactory.classElement2("D", []);
+    ClassElementImpl classD = ElementFactory.classElement2("D");
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory.setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
     expect(mapD.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_2_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class A implements I1, I2 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElement methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM2.parameters = <ParameterElement> [parameter1];
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     expect(mapA.get(methodName), same(methodM2));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_3_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class I3 { int m([int, int]); }
     // class A implements I1, I2, I3 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM1.parameters = <ParameterElement> [parameter1];
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
-    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI3 = ElementFactory.classElement2("I3");
+    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a2"));
     parameter2.type = _typeProvider.intType;
     parameter2.parameterKind = ParameterKind.POSITIONAL;
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a3"));
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM3.parameters = <ParameterElement> [parameter2, parameter3];
     classI3.methods = <MethodElement> [methodM3];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     expect(mapA.get(methodName), same(methodM3));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_4_methods() {
     // class I1 { int m(); }
     // class I2 { int m(); }
     // class I3 { int m([int]); }
     // class I4 { int m([int, int]); }
     // class A implements I1, I2, I3, I4 {}
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElement methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
-    MethodElement methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
+    MethodElement methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI2.methods = <MethodElement> [methodM2];
-    ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
-    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI3 = ElementFactory.classElement2("I3");
+    MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM3.parameters = <ParameterElement> [parameter1];
     classI3.methods = <MethodElement> [methodM3];
-    ClassElementImpl classI4 = ElementFactory.classElement2("I4", []);
-    MethodElementImpl methodM4 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classI4 = ElementFactory.classElement2("I4");
+    MethodElementImpl methodM4 = ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a2"));
     parameter2.type = _typeProvider.intType;
     parameter2.parameterKind = ParameterKind.POSITIONAL;
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a3"));
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM4.parameters = <ParameterElement> [parameter2, parameter3];
     classI4.methods = <MethodElement> [methodM4];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type, classI4.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     expect(mapA.get(methodName), same(methodM4));
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_interface_getter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_method() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_setter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_staticMember() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interfaces_infiniteLoop() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_interfaces_infiniteLoop2() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classA.interfaces = <InterfaceType> [classB.type];
     classB.interfaces = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interfaces_union2() {
-    ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
+    ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName1 = "m1";
-    MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType, []);
+    MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType);
     classI1.methods = <MethodElement> [methodM1];
-    ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
+    ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     String methodName2 = "m2";
-    MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType, []);
+    MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType);
     classI2.methods = <MethodElement> [methodM2];
     classI2.interfaces = <InterfaceType> [classI1.type];
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType> [classI2.type];
     expect(_inheritanceManager.lookupInheritance(classA, methodName1), same(methodM1));
     expect(_inheritanceManager.lookupInheritance(classA, methodName2), same(methodM2));
     _assertNoErrors(classI1);
     _assertNoErrors(classI2);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_mixin_getter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_method() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_setter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_staticMember() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.mixins = <InterfaceType> [classA.type];
     expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_noMember() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     expect(_inheritanceManager.lookupInheritance(classA, "a"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_superclass_getter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_infiniteLoop() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.supertype = classA.type;
     expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_superclass_infiniteLoop2() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classA.supertype = classB.type;
     classB.supertype = classA.type;
     expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_method() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_setter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_staticMember() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupMember_getter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     expect(_inheritanceManager.lookupMember(classA, getterName), same(getterG));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_getter_static() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, true, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     expect(_inheritanceManager.lookupMember(classA, getterName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_method() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
     expect(_inheritanceManager.lookupMember(classA, methodName), same(methodM));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_method_static() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
     expect(_inheritanceManager.lookupMember(classA, methodName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_noMember() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     expect(_inheritanceManager.lookupMember(classA, "a"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_setter() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
     expect(_inheritanceManager.lookupMember(classA, "$setterName="), same(setterS));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_setter_static() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, true, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
     expect(_inheritanceManager.lookupMember(classA, setterName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupOverrides_noParentClasses() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElementImpl methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodM = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodM];
     expect(_inheritanceManager.lookupOverrides(classA, methodName), hasLength(0));
     _assertNoErrors(classA);
   }
 
   void test_lookupOverrides_overrideBaseClass() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodMinA];
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
+    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classB.methods = <MethodElement> [methodMinB];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classB, methodName);
     expect(overrides, unorderedEquals([methodMinA]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupOverrides_overrideInterface() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodMinA];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
     classB.interfaces = <InterfaceType> [classA.type];
-    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classB.methods = <MethodElement> [methodMinB];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classB, methodName);
     expect(overrides, unorderedEquals([methodMinA]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupOverrides_overrideTwoInterfaces() {
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     String methodName = "m";
-    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
+    MethodElementImpl methodMinA = ElementFactory.methodElement(methodName, _typeProvider.intType);
     classA.methods = <MethodElement> [methodMinA];
-    ClassElementImpl classB = ElementFactory.classElement2("B", []);
-    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.doubleType, []);
+    ClassElementImpl classB = ElementFactory.classElement2("B");
+    MethodElementImpl methodMinB = ElementFactory.methodElement(methodName, _typeProvider.doubleType);
     classB.methods = <MethodElement> [methodMinB];
-    ClassElementImpl classC = ElementFactory.classElement2("C", []);
+    ClassElementImpl classC = ElementFactory.classElement2("C");
     classC.interfaces = <InterfaceType> [classA.type, classB.type];
-    MethodElementImpl methodMinC = ElementFactory.methodElement(methodName, _typeProvider.numType, []);
+    MethodElementImpl methodMinC = ElementFactory.methodElement(methodName, _typeProvider.numType);
     classC.methods = <MethodElement> [methodMinC];
     List<ExecutableElement> overrides = _inheritanceManager.lookupOverrides(classC, methodName);
     expect(overrides, unorderedEquals([methodMinA, methodMinB]));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
     _assertNoErrors(classC);
   }
 
-  void _assertErrors(ClassElement classElt, List<ErrorCode> expectedErrorCodes) {
+  void _assertErrors(ClassElement classElt, [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     HashSet<AnalysisError> actualErrors = _inheritanceManager.getErrors(classElt);
     if (actualErrors != null) {
       for (AnalysisError error in actualErrors) {
         errorListener.onError(error);
       }
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void _assertNoErrors(ClassElement classElt) {
-    _assertErrors(classElt, []);
+    _assertErrors(classElt);
   }
 
   /**
    * Create the inheritance manager used by the tests.
    *
    * @return the inheritance manager that was created
    */
   InheritanceManager _createInheritanceManager() {
     AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source = new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
@@ skipping 24 matching lines @@
     Source librarySource = addSource("/lib.dart", r'''
 library lib;
 part 'first.dart';
 part 'second.dart';''');
     addSource("/first.dart", r'''
 part of lib;
 int get V => 0;''');
     addSource("/second.dart", r'''
 part of lib;
 void set V(int v) {}''');
-    LibraryElement element = _buildLibrary(librarySource, []);
+    LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     expect(sourcedUnits, hasLength(2));
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
     expect(firstAccessors, hasLength(1));
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
     expect(secondAccessors, hasLength(1));
     expect(secondAccessors[0].variable, same(firstAccessors[0].variable));
   }
 
   void test_empty() {
     Source librarySource = addSource("/lib.dart", "library lib;");
-    LibraryElement element = _buildLibrary(librarySource, []);
+    LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     expect(element.name, "lib");
     expect(element.entryPoint, isNull);
     expect(element.importedLibraries, hasLength(0));
     expect(element.imports, hasLength(0));
     expect(element.library, same(element));
     expect(element.prefixes, hasLength(0));
     expect(element.parts, hasLength(0));
     CompilationUnitElement unit = element.definingCompilationUnit;
     expect(unit, isNotNull);
@@ skipping 29 matching lines @@
 part 'first.dart';
 part 'second.dart';
 
 class A {}''');
     addSource("/first.dart", r'''
 part of lib;
 class B {}''');
     addSource("/second.dart", r'''
 part of lib;
 class C {}''');
-    LibraryElement element = _buildLibrary(librarySource, []);
+    LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     expect(sourcedUnits, hasLength(2));
     _assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       _assertTypes(sourcedUnits[0], ["B"]);
       _assertTypes(sourcedUnits[1], ["C"]);
     } else {
       _assertTypes(sourcedUnits[0], ["C"]);
       _assertTypes(sourcedUnits[1], ["B"]);
     }
   }
 
   void test_singleFile() {
     Source librarySource = addSource("/lib.dart", r'''
 library lib;
 
 class A {}''');
-    LibraryElement element = _buildLibrary(librarySource, []);
+    LibraryElement element = _buildLibrary(librarySource);
     expect(element, isNotNull);
     _assertTypes(element.definingCompilationUnit, ["A"]);
   }
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
@@ skipping 37 matching lines @@
 
   /**
    * Build the element model for the library whose defining compilation unit has the given source.
    *
    * @param librarySource the source of the defining compilation unit for the library
    * @param expectedErrorCodes the errors that are expected to be found while building the element
    *          model
    * @return the element model that was built for the library
    * @throws Exception if the element model could not be built
    */
-  LibraryElement _buildLibrary(Source librarySource, List<ErrorCode> expectedErrorCodes) {
+  LibraryElement _buildLibrary(Source librarySource, [List<ErrorCode> expectedErrorCodes = ErrorCode.EMPTY_LIST]) {
     LibraryResolver resolver = new LibraryResolver(_context);
     LibraryElementBuilder builder = new LibraryElementBuilder(resolver.analysisContext, resolver.errorListener);
     Library library = resolver.createLibrary(librarySource);
     LibraryElement element = builder.buildLibrary(library);
     GatheringErrorListener listener = new GatheringErrorListener();
     listener.addAll2(resolver.errorListener);
     listener.assertErrorsWithCodes(expectedErrorCodes);
     return element;
   }
 }
 
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
-    ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
-    ClassElement typeB1 = ElementFactory.classElement2(typeNameB, []);
-    ClassElement typeB2 = ElementFactory.classElement2(typeNameB, []);
-    ClassElement typeC = ElementFactory.classElement2(typeNameC, []);
-    LibraryElement importedLibrary1 = createTestLibrary(context, "imported1", []);
+    ClassElement typeA = ElementFactory.classElement2(typeNameA);
+    ClassElement typeB1 = ElementFactory.classElement2(typeNameB);
+    ClassElement typeB2 = ElementFactory.classElement2(typeNameB);
+    ClassElement typeC = ElementFactory.classElement2(typeNameC);
+    LibraryElement importedLibrary1 = createTestLibrary(context, "imported1");
     (importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeA, typeB1];
-    ImportElementImpl import1 = ElementFactory.importFor(importedLibrary1, null, []);
-    LibraryElement importedLibrary2 = createTestLibrary(context, "imported2", []);
+    ImportElementImpl import1 = ElementFactory.importFor(importedLibrary1, null);
+    LibraryElement importedLibrary2 = createTestLibrary(context, "imported2");
     (importedLibrary2.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeB2, typeC];
-    ImportElementImpl import2 = ElementFactory.importFor(importedLibrary2, null, []);
-    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
+    ImportElementImpl import2 = ElementFactory.importFor(importedLibrary2, null);
+    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement> [import1, import2];
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary), typeA);
       errorListener.assertNoErrors();
       expect(scope.lookup(AstFactory.identifier3(typeNameC), importingLibrary), typeC);
       errorListener.assertNoErrors();
       Element element = scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary);
       errorListener.assertErrorsWithCodes([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, element);
       List<Element> conflictingElements = (element as MultiplyDefinedElement).conflictingElements;
       expect(conflictingElements, hasLength(2));
       if (identical(conflictingElements[0], typeB1)) {
         expect(conflictingElements[1], same(typeB2));
       } else if (identical(conflictingElements[0], typeB2)) {
         expect(conflictingElements[1], same(typeB1));
       } else {
         expect(conflictingElements[0], same(typeB1));
       }
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       Identifier identifier = AstFactory.identifier3(typeNameB);
-      AstFactory.methodDeclaration(null, AstFactory.typeName3(identifier, []), null, null, AstFactory.identifier3("foo"), null);
+      AstFactory.methodDeclaration(null, AstFactory.typeName3(identifier), null, null, AstFactory.identifier3("foo"), null);
       Element element = scope.lookup(identifier, importingLibrary);
       errorListener.assertErrorsWithCodes([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, element);
     }
   }
 
   void test_creation_empty() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryImportScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
-    LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
+    LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
-    LibraryElementImpl definingLibrary = createTestLibrary(context, "importing", []);
+    LibraryElementImpl definingLibrary = createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(definingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary), importedType);
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     expect(scope.errorListener, errorListener);
   }
 
   void test_nonConflictingImports_fromSdk() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "List";
-    ClassElement type = ElementFactory.classElement2(typeName, []);
-    LibraryElement importedLibrary = createTestLibrary(context, "lib", []);
+    ClassElement type = ElementFactory.classElement2(typeName);
+    LibraryElement importedLibrary = createTestLibrary(context, "lib");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [type];
-    ImportElementImpl importCore = ElementFactory.importFor(context.getLibraryElement(context.sourceFactory.forUri("dart:core")), null, []);
-    ImportElementImpl importLib = ElementFactory.importFor(importedLibrary, null, []);
-    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
+    ImportElementImpl importCore = ElementFactory.importFor(context.getLibraryElement(context.sourceFactory.forUri("dart:core")), null);
+    ImportElementImpl importLib = ElementFactory.importFor(importedLibrary, null);
+    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement> [importCore, importLib];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(typeName), importingLibrary), type);
     errorListener.assertErrorsWithCodes([StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   void test_nonConflictingImports_sameElement() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeNameA = "A";
     String typeNameB = "B";
-    ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
-    ClassElement typeB = ElementFactory.classElement2(typeNameB, []);
-    LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
+    ClassElement typeA = ElementFactory.classElement2(typeNameA);
+    ClassElement typeB = ElementFactory.classElement2(typeNameB);
+    LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeA, typeB];
-    ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null, []);
-    ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null, []);
-    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
+    ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null);
+    ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null);
+    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement> [import1, import2];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary), typeA);
     errorListener.assertNoErrors();
     expect(scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary), typeB);
     errorListener.assertNoErrors();
   }
 
   void test_prefixedAndNonPrefixed() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeName = "C";
     String prefixName = "p";
-    ClassElement prefixedType = ElementFactory.classElement2(typeName, []);
-    ClassElement nonPrefixedType = ElementFactory.classElement2(typeName, []);
-    LibraryElement prefixedLibrary = createTestLibrary(context, "import.prefixed", []);
+    ClassElement prefixedType = ElementFactory.classElement2(typeName);
+    ClassElement nonPrefixedType = ElementFactory.classElement2(typeName);
+    LibraryElement prefixedLibrary = createTestLibrary(context, "import.prefixed");
     (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [prefixedType];
-    ImportElementImpl prefixedImport = ElementFactory.importFor(prefixedLibrary, ElementFactory.prefix(prefixName), []);
-    LibraryElement nonPrefixedLibrary = createTestLibrary(context, "import.nonPrefixed", []);
+    ImportElementImpl prefixedImport = ElementFactory.importFor(prefixedLibrary, ElementFactory.prefix(prefixName));
+    LibraryElement nonPrefixedLibrary = createTestLibrary(context, "import.nonPrefixed");
     (nonPrefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [nonPrefixedType];
-    ImportElementImpl nonPrefixedImport = ElementFactory.importFor(nonPrefixedLibrary, null, []);
-    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
+    ImportElementImpl nonPrefixedImport = ElementFactory.importFor(nonPrefixedLibrary, null);
+    LibraryElementImpl importingLibrary = createTestLibrary(context, "importing");
     importingLibrary.imports = <ImportElement> [prefixedImport, nonPrefixedImport];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     Element prefixedElement = scope.lookup(AstFactory.identifier5(prefixName, typeName), importingLibrary);
     errorListener.assertNoErrors();
     expect(prefixedElement, same(prefixedType));
     Element nonPrefixedElement = scope.lookup(AstFactory.identifier3(typeName), importingLibrary);
     errorListener.assertNoErrors();
     expect(nonPrefixedElement, same(nonPrefixedType));
   }
@@ skipping 89 matching lines @@
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
-    LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
+    LibraryElement importedLibrary = createTestLibrary(context, "imported");
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
-    LibraryElementImpl definingLibrary = createTestLibrary(context, "importing", []);
+    LibraryElementImpl definingLibrary = createTestLibrary(context, "importing");
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryScope(definingLibrary, errorListener);
     expect(scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary), importedType);
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
@@ skipping 113 matching lines @@
   /**
    * The null type.
    */
   InterfaceType _nullType;
 
   void setUp() {
     _nullType = new TestTypeProvider().nullType;
   }
 
   void test_MemberMap_copyConstructor() {
-    MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
-    MethodElement m2 = ElementFactory.methodElement("m2", _nullType, []);
-    MethodElement m3 = ElementFactory.methodElement("m3", _nullType, []);
+    MethodElement m1 = ElementFactory.methodElement("m1", _nullType);
+    MethodElement m2 = ElementFactory.methodElement("m2", _nullType);
+    MethodElement m3 = ElementFactory.methodElement("m3", _nullType);
     MemberMap map = new MemberMap();
     map.put(m1.name, m1);
     map.put(m2.name, m2);
     map.put(m3.name, m3);
     MemberMap copy = new MemberMap.con2(map);
     expect(copy.size, map.size);
     expect(copy.get(m1.name), m1);
     expect(copy.get(m2.name), m2);
     expect(copy.get(m3.name), m3);
   }
 
   void test_MemberMap_override() {
-    MethodElement m1 = ElementFactory.methodElement("m", _nullType, []);
-    MethodElement m2 = ElementFactory.methodElement("m", _nullType, []);
+    MethodElement m1 = ElementFactory.methodElement("m", _nullType);
+    MethodElement m2 = ElementFactory.methodElement("m", _nullType);
     MemberMap map = new MemberMap();
     map.put(m1.name, m1);
     map.put(m2.name, m2);
     expect(map.size, 1);
     expect(map.get("m"), m2);
   }
 
   void test_MemberMap_put() {
-    MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
+    MethodElement m1 = ElementFactory.methodElement("m1", _nullType);
     MemberMap map = new MemberMap();
     expect(map.size, 0);
     map.put(m1.name, m1);
     expect(map.size, 1);
     expect(map.get("m1"), m1);
   }
 }
 
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
@@ skipping 213 matching lines @@
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithAndWithoutExperimental(<String> [
         r'''
 library lib1;
 f() {}''',
         r'''
 library root;
 import 'lib1.dart' deferred as lib1;
-main() { lib1.f(); }'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> []);
+main() { lib1.f(); }'''], <ErrorCode>[ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], ErrorCode.EMPTY_LIST);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_1() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     Source source = addSource(r'''
 f(var message, var dynamic_) {
   if (message is Function) {
     message = dynamic_;
   }
   int s = message;
@@ skipping 508 matching lines @@
     Source source = addSource(r'''
 library L;
 @A()
 import 'lib1.dart';''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {
   const A() {}
 }''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     verify([source, source2]);
   }
 
   void test_unusedImport_as_equalPrefixes() {
     // 18818
     Source source = addSource(r'''
 library L;
 import 'lib1.dart' as one;
 import 'lib2.dart' as one;
 one.A a;
 one.B b;''');
     Source source2 = addNamedSource("/lib1.dart", r'''
 library lib1;
 class A {}''');
     Source source3 = addNamedSource("/lib2.dart", r'''
 library lib2;
 class B {}''');
     resolve(source);
-    assertErrors(source, []);
+    assertErrors(source);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_unusedImport_core_library() {
     Source source = addSource(r'''
 library L;
 import 'dart:core';''');
     resolve(source);
@@ skipping 534 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();
     for (AnalysisError error in analysisContext2.computeErrors(source)) {
       if (error.errorCode == HintCode.UNUSED_LOCAL_VARIABLE &&
           !enableUnusedLocalVariable) {
         continue;
       }
       errorListener.onError(error);
     }
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been reported against the given source.
    *
    * @param source the source against which no errors should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if any errors have been reported
    */
   void assertNoErrors(Source source) {
-    assertErrors(source, []);
+    assertErrors(source);
   }
 
   /**
    * Cache the source file content in the source factory but don't add the source to the analysis
    * context. The file path should be absolute.
    *
    * @param filePath the path of the file being cached
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(FileUtilities2.createFile(filePath));
     analysisContext2.setContents(source, contents);
     return source;
   }
 
   /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    *
    * @return the library element that was created
    */
-  LibraryElementImpl createDefaultTestLibrary() => createTestLibrary(new AnalysisContextImpl(), "test", []);
+  LibraryElementImpl createDefaultTestLibrary() => createTestLibrary(new AnalysisContextImpl(), "test");
 
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    *
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
-  LibraryElementImpl createTestLibrary(AnalysisContext context, String libraryName, List<String> typeNames) {
-    int count = typeNames.length;
-    List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>(count);
-    for (int i = 0; i < count; i++) {
-      String typeName = typeNames[i];
-      ClassElementImpl type = new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
-      String fileName = "$typeName.dart";
-      CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
-      compilationUnit.source = _createNamedSource(fileName);
-      compilationUnit.types = <ClassElement> [type];
-      sourcedCompilationUnits[i] = compilationUnit;
+  LibraryElementImpl createTestLibrary(AnalysisContext context, String libraryName, [List<String> typeNames]) {
+    List<CompilationUnitElement> sourcedCompilationUnits;
+    if (typeNames == null) {
+      sourcedCompilationUnits = CompilationUnitElementImpl.EMPTY_ARRAY;
+    } else {
+      int count = typeNames.length;
+      sourcedCompilationUnits = new List<CompilationUnitElement>(count);
+      for (int i = 0; i < count; i++) {
+        String typeName = typeNames[i];
+        ClassElementImpl type = new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
+        String fileName = "$typeName.dart";
+        CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
+        compilationUnit.source = _createNamedSource(fileName);
+        compilationUnit.types = <ClassElement> [type];
+        sourcedCompilationUnits[i] = compilationUnit;
+      }
     }
     String fileName = "$libraryName.dart";
     CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
     compilationUnit.source = _createNamedSource(fileName);
     LibraryElementImpl library = new LibraryElementImpl.forNode(context, AstFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
 
@@ skipping 249 matching lines @@
       ScopeBuilder.scopeFor(AstFactory.compilationUnit(), listener);
       fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   ClassDeclaration _createResolvedClassDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
-    ClassDeclaration classNode = AstFactory.classDeclaration(null, className, AstFactory.typeParameterList([]), null, null, null, []);
+    ClassDeclaration classNode = AstFactory.classDeclaration(null, className, AstFactory.typeParameterList(), null, null, null);
     unit.declarations.add(classNode);
-    ClassElement classElement = ElementFactory.classElement2(className, []);
+    ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
     (unit.element as CompilationUnitElementImpl).types = <ClassElement> [classElement];
     return classNode;
   }
 
   ClassTypeAlias _createResolvedClassTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
-    ClassTypeAlias classNode = AstFactory.classTypeAlias(className, AstFactory.typeParameterList([]), null, null, null, null);
+    ClassTypeAlias classNode = AstFactory.classTypeAlias(className, AstFactory.typeParameterList(), null, null, null, null);
     unit.declarations.add(classNode);
-    ClassElement classElement = ElementFactory.classElement2(className, []);
+    ClassElement classElement = ElementFactory.classElement2(className);
     classNode.name.staticElement = classElement;
     (unit.element as CompilationUnitElementImpl).types = <ClassElement> [classElement];
     return classNode;
   }
 
   CompilationUnit _createResolvedCompilationUnit() {
     CompilationUnit unit = AstFactory.compilationUnit();
     LibraryElementImpl library = ElementFactory.library(AnalysisContextFactory.contextWithCore(), "lib");
     unit.element = library.definingCompilationUnit;
     return unit;
   }
 
   ConstructorDeclaration _createResolvedConstructorDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String constructorName = "f";
-    ConstructorDeclaration constructorNode = AstFactory.constructorDeclaration(AstFactory.identifier3(constructorName), null, AstFactory.formalParameterList([]), null);
+    ConstructorDeclaration constructorNode = AstFactory.constructorDeclaration(AstFactory.identifier3(constructorName), null, AstFactory.formalParameterList(), null);
     classNode.members.add(constructorNode);
-    ConstructorElement constructorElement = ElementFactory.constructorElement2(classNode.element, null, []);
+    ConstructorElement constructorElement = ElementFactory.constructorElement2(classNode.element, null);
     constructorNode.element = constructorElement;
     (classNode.element as ClassElementImpl).constructors = <ConstructorElement> [constructorElement];
     return constructorNode;
   }
 
   FunctionDeclaration _createResolvedFunctionDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String functionName = "f";
     FunctionDeclaration functionNode = AstFactory.functionDeclaration(null, null, functionName, AstFactory.functionExpression());
     unit.declarations.add(functionNode);
     FunctionElement functionElement = ElementFactory.functionElement(functionName);
     functionNode.name.staticElement = functionElement;
     (unit.element as CompilationUnitElementImpl).functions = <FunctionElement> [functionElement];
     return functionNode;
   }
 
   FunctionTypeAlias _createResolvedFunctionTypeAlias() {
     CompilationUnit unit = _createResolvedCompilationUnit();
-    FunctionTypeAlias aliasNode = AstFactory.typeAlias(AstFactory.typeName4("A", []), "F", AstFactory.typeParameterList([]), AstFactory.formalParameterList([]));
+    FunctionTypeAlias aliasNode = AstFactory.typeAlias(AstFactory.typeName4("A"), "F", AstFactory.typeParameterList(), AstFactory.formalParameterList());
     unit.declarations.add(aliasNode);
     SimpleIdentifier aliasName = aliasNode.name;
     FunctionTypeAliasElement aliasElement = new FunctionTypeAliasElementImpl.forNode(aliasName);
     aliasName.staticElement = aliasElement;
     (unit.element as CompilationUnitElementImpl).typeAliases = <FunctionTypeAliasElement> [aliasElement];
     return aliasNode;
   }
 
   MethodDeclaration _createResolvedMethodDeclaration() {
     ClassDeclaration classNode = _createResolvedClassDeclaration();
     String methodName = "f";
-    MethodDeclaration methodNode = AstFactory.methodDeclaration(null, null, null, null, AstFactory.identifier3(methodName), AstFactory.formalParameterList([]));
+    MethodDeclaration methodNode = AstFactory.methodDeclaration(null, null, null, null, AstFactory.identifier3(methodName), AstFactory.formalParameterList());
     classNode.members.add(methodNode);
-    MethodElement methodElement = ElementFactory.methodElement(methodName, null, []);
+    MethodElement methodElement = ElementFactory.methodElement(methodName, null);
     methodNode.name.staticElement = methodElement;
     (classNode.element as ClassElementImpl).methods = <MethodElement> [methodElement];
     return methodNode;
   }
 }
 
 class ScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
@@ skipping 1145 matching lines @@
   void test_visitAdjacentStrings() {
     // "a" "b"
     Expression node = AstFactory.adjacentStrings([_resolvedString("a"), _resolvedString("b")]);
     expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitAsExpression() {
     // class A { ... this as B ... }
     // class B extends A {}
-    ClassElement superclass = ElementFactory.classElement2("A", []);
+    ClassElement superclass = ElementFactory.classElement2("A");
     InterfaceType superclassType = superclass.type;
-    ClassElement subclass = ElementFactory.classElement("B", superclassType, []);
-    Expression node = AstFactory.asExpression(AstFactory.thisExpression(), AstFactory.typeName(subclass, []));
+    ClassElement subclass = ElementFactory.classElement("B", superclassType);
+    Expression node = AstFactory.asExpression(AstFactory.thisExpression(), AstFactory.typeName(subclass));
     expect(_analyze3(node, superclassType), same(subclass.type));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
     // i += 1
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier identifier = _resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = AstFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, _resolvedInteger(1));
     MethodElement plusMethod = getMethod(numType, "+");
@@ skipping 60 matching lines @@
     node.staticElement = getMethod(_typeProvider.numType, "/");
     expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_star_notSpecial() {
     // class A {
     //   A operator *(double value);
     // }
     // (a as A) * 2.0
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     InterfaceType typeA = classA.type;
     MethodElement operator = ElementFactory.methodElement("*", typeA, [_typeProvider.doubleType]);
     classA.methods = <MethodElement> [operator];
-    BinaryExpression node = AstFactory.binaryExpression(AstFactory.asExpression(AstFactory.identifier3("a"), AstFactory.typeName(classA, [])), TokenType.PLUS, _resolvedDouble(2.0));
+    BinaryExpression node = AstFactory.binaryExpression(AstFactory.asExpression(AstFactory.identifier3("a"), AstFactory.typeName(classA)), TokenType.PLUS, _resolvedDouble(2.0));
     node.staticElement = operator;
     expect(_analyze(node), same(typeA));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_starID() {
     // 1 * 2.0
     BinaryExpression node = AstFactory.binaryExpression(_resolvedInteger(1), TokenType.PLUS, _resolvedDouble(2.0));
     node.staticElement = getMethod(_typeProvider.numType, "*");
     expect(_analyze(node), same(_typeProvider.doubleType));
@@ skipping 42 matching lines @@
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_named_block() {
     // ({p1 : 0, p2 : 0}) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p1"), _resolvedInteger(0));
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2([]));
+    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
     Map<String, DartType> expectedNamedTypes = new HashMap<String, DartType>();
     expectedNamedTypes["p1"] = dynamicType;
     expectedNamedTypes["p2"] = dynamicType;
     _assertFunctionType(dynamicType, null, null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
@@ skipping 11 matching lines @@
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normal_block() {
     // (p1, p2) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.simpleFormalParameter3("p2");
     _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2([]));
+    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
     _assertFunctionType(dynamicType, <DartType> [dynamicType, dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normal_expression() {
     // (p1, p2) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p = AstFactory.simpleFormalParameter3("p");
     _setType(p, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p]), AstFactory.expressionFunctionBody(_resolvedInteger(0)));
     _analyze5(p);
     DartType resultType = _analyze(node);
     _assertFunctionType(_typeProvider.intType, <DartType> [dynamicType], null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndNamed_block() {
     // (p1, {p2 : 0}) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2([]));
+    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2());
     _analyze5(p2);
     DartType resultType = _analyze(node);
     Map<String, DartType> expectedNamedTypes = new HashMap<String, DartType>();
     expectedNamedTypes["p2"] = dynamicType;
     _assertFunctionType(dynamicType, <DartType> [dynamicType], null, expectedNamedTypes, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndNamed_expression() {
     // (p1, {p2 : 0}) -> 0
@@ skipping 11 matching lines @@
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_block() {
     // (p1, [p2 = 0]) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2([]));
+    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
     _assertFunctionType(dynamicType, <DartType> [dynamicType], <DartType> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_normalAndPositional_expression() {
     // (p1, [p2 = 0]) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.simpleFormalParameter3("p1");
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
     FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.expressionFunctionBody(_resolvedInteger(0)));
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
     _assertFunctionType(_typeProvider.intType, <DartType> [dynamicType], <DartType> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_block() {
     // ([p1 = 0, p2 = 0]) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p1"), _resolvedInteger(0));
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.positionalFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
-    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2([]));
+    FunctionExpression node = _resolvedFunctionExpression(AstFactory.formalParameterList([p1, p2]), AstFactory.blockFunctionBody2());
     _analyze5(p1);
     _analyze5(p2);
     DartType resultType = _analyze(node);
     _assertFunctionType(dynamicType, null, <DartType> [dynamicType, dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_positional_expression() {
     // ([p1 = 0, p2 = 0]) -> 0
     DartType dynamicType = _typeProvider.dynamicType;
@@ skipping 68 matching lines @@
     indexExpression.staticElement = indexMethod;
     // list[0] should be in a setter context
     AstFactory.assignmentExpression(indexExpression, TokenType.EQ, AstFactory.integer(0));
     // analyze and assert result of the index expression
     expect(_analyze(indexExpression), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_named() {
     // new C.m()
-    ClassElementImpl classElement = ElementFactory.classElement2("C", []);
+    ClassElementImpl classElement = ElementFactory.classElement2("C");
     String constructorName = "m";
-    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, constructorName, []);
+    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, constructorName);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
-    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement, []), [AstFactory.identifier3(constructorName)]);
+    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement), [AstFactory.identifier3(constructorName)]);
     node.staticElement = constructor;
     expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_typeParameters() {
     // new C<I>()
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
-    ClassElementImpl elementI = ElementFactory.classElement2("I", []);
-    ConstructorElementImpl constructor = ElementFactory.constructorElement2(elementC, null, []);
+    ClassElementImpl elementI = ElementFactory.classElement2("I");
+    ConstructorElementImpl constructor = ElementFactory.constructorElement2(elementC, null);
     elementC.constructors = <ConstructorElement> [constructor];
     constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
-    TypeName typeName = AstFactory.typeName(elementC, [AstFactory.typeName(elementI, [])]);
+    TypeName typeName = AstFactory.typeName(elementC, [AstFactory.typeName(elementI)]);
     typeName.type = elementC.type.substitute4(<DartType> [elementI.type]);
-    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, typeName, []);
+    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, typeName);
     node.staticElement = constructor;
     InterfaceType interfaceType = _analyze(node) as InterfaceType;
     List<DartType> typeArgs = interfaceType.typeArguments;
     expect(typeArgs.length, 1);
     expect(typeArgs[0], elementI.type);
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
     // new C()
-    ClassElementImpl classElement = ElementFactory.classElement2("C", []);
-    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, null, []);
+    ClassElementImpl classElement = ElementFactory.classElement2("C");
+    ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, null);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
-    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement, []), []);
+    InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement));
     node.staticElement = constructor;
     expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitIntegerLiteral() {
     // 42
     Expression node = _resolvedInteger(42);
     expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_negated() {
     // a is! String
-    Expression node = AstFactory.isExpression(_resolvedString("a"), true, AstFactory.typeName4("String", []));
+    Expression node = AstFactory.isExpression(_resolvedString("a"), true, AstFactory.typeName4("String"));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_notNegated() {
     // a is String
-    Expression node = AstFactory.isExpression(_resolvedString("a"), false, AstFactory.typeName4("String", []));
+    Expression node = AstFactory.isExpression(_resolvedString("a"), false, AstFactory.typeName4("String"));
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_empty() {
     // []
-    Expression node = AstFactory.listLiteral([]);
+    Expression node = AstFactory.listLiteral();
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.listType.substitute4(<DartType> [_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_nonEmpty() {
     // [0]
     Expression node = AstFactory.listLiteral([_resolvedInteger(0)]);
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.listType.substitute4(<DartType> [_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_empty() {
     // {}
-    Expression node = AstFactory.mapLiteral2([]);
+    Expression node = AstFactory.mapLiteral2();
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.mapType.substitute4(<DartType> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_nonEmpty() {
     // {"k" : 0}
     Expression node = AstFactory.mapLiteral2([AstFactory.mapLiteralEntry("k", _resolvedInteger(0))]);
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.mapType.substitute4(<DartType> [_typeProvider.dynamicType, _typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_then() {
     // then()
-    Expression node = AstFactory.methodInvocation(null, "then", []);
+    Expression node = AstFactory.methodInvocation(null, "then");
     _analyze(node);
     _listener.assertNoErrors();
   }
 
   void test_visitNamedExpression() {
     // n: a
     Expression node = AstFactory.namedExpression2("n", _resolvedString("a"));
     expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
@@ skipping 164 matching lines @@
     Expression node = AstFactory.string([
         AstFactory.interpolationString("a", "a"),
         AstFactory.interpolationExpression(_resolvedString("b")),
         AstFactory.interpolationString("c", "c")]);
     expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitSuperExpression() {
     // super
-    InterfaceType superType = ElementFactory.classElement2("A", []).type;
-    InterfaceType thisType = ElementFactory.classElement("B", superType, []).type;
+    InterfaceType superType = ElementFactory.classElement2("A").type;
+    InterfaceType thisType = ElementFactory.classElement("B", superType).type;
     Expression node = AstFactory.superExpression();
     expect(_analyze3(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitSymbolLiteral() {
     expect(_analyze(AstFactory.symbolLiteral(["a"])), same(_typeProvider.symbolType));
   }
 
   void test_visitThisExpression() {
     // this
-    InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.classElement2("A", []).type, []).type;
+    InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.classElement2("A").type).type;
     Expression node = AstFactory.thisExpression();
     expect(_analyze3(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitThrowExpression_withoutValue() {
     // throw
     Expression node = AstFactory.throwExpression();
     expect(_analyze(node), same(_typeProvider.bottomType));
     _listener.assertNoErrors();
@@ skipping 703 matching lines @@
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
 
   void test_computeAllSubtypes_infiniteLoop() {
     //
     // class A extends B
     // class B extends A
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     classA.supertype = classB.type;
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(2));
     expect(arraySubtypesOfA, unorderedEquals([classA, classB]));
   }
 
   void test_computeAllSubtypes_manyRecursiveSubtypes() {
     //
     // class A
     // class B extends A
     // class C extends B
     // class D extends B
     // class E extends B
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
-    ClassElementImpl classD = ElementFactory.classElement("D", classB.type, []);
-    ClassElementImpl classE = ElementFactory.classElement("E", classB.type, []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
+    ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
+    ClassElementImpl classD = ElementFactory.classElement("D", classB.type);
+    ClassElementImpl classE = ElementFactory.classElement("E", classB.type);
     _definingCompilationUnit.types = <ClassElement> [classA, classB, classC, classD, classE];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     HashSet<ClassElement> subtypesOfB = _subtypeManager.computeAllSubtypes(classB);
     List<ClassElement> arraySubtypesOfB = new List.from(subtypesOfB);
     expect(subtypesOfA, hasLength(4));
     expect(arraySubtypesOfA, unorderedEquals([classB, classC, classD, classE]));
     expect(subtypesOfB, hasLength(3));
     expect(arraySubtypesOfB, unorderedEquals([classC, classD, classE]));
   }
 
   void test_computeAllSubtypes_noSubtypes() {
     //
     // class A
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
     _definingCompilationUnit.types = <ClassElement> [classA];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     expect(subtypesOfA, hasLength(0));
   }
 
   void test_computeAllSubtypes_oneSubtype() {
     //
     // class A
     // class B extends A
     //
-    ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
+    ClassElementImpl classA = ElementFactory.classElement2("A");
+    ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     _definingCompilationUnit.types = <ClassElement> [classA, classB];
     HashSet<ClassElement> subtypesOfA = _subtypeManager.computeAllSubtypes(classA);
     List<ClassElement> arraySubtypesOfA = new List.from(subtypesOfA);
     expect(subtypesOfA, hasLength(1));
     expect(arraySubtypesOfA, unorderedEquals([classB]));
   }
 
   @override
   void setUp() {
     super.setUp();
@@ skipping 103 matching lines @@
   InterfaceType _typeType;
 
   /**
    * The type representing typenames that can't be resolved.
    */
   DartType _undefinedType;
 
   @override
   InterfaceType get boolType {
     if (_boolType == null) {
-      ClassElementImpl boolElement = ElementFactory.classElement2("bool", []);
+      ClassElementImpl boolElement = ElementFactory.classElement2("bool");
       _boolType = boolElement.type;
-      ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(boolElement, "fromEnvironment", true, []);
+      ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(boolElement, "fromEnvironment", true);
       fromEnvironment.parameters = <ParameterElement> [
           ElementFactory.requiredParameter2("name", stringType),
           ElementFactory.namedParameter2("defaultValue", _boolType)];
       fromEnvironment.factory = true;
       boolElement.constructors = <ConstructorElement> [fromEnvironment];
     }
     return _boolType;
   }
 
   @override
   DartType get bottomType {
     if (_bottomType == null) {
       _bottomType = BottomTypeImpl.instance;
     }
     return _bottomType;
   }
 
   @override
   InterfaceType get deprecatedType {
     if (_deprecatedType == null) {
-      ClassElementImpl deprecatedElement = ElementFactory.classElement2("Deprecated", []);
+      ClassElementImpl deprecatedElement = ElementFactory.classElement2("Deprecated");
       deprecatedElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(deprecatedElement, null, true, [stringType])];
       _deprecatedType = deprecatedElement.type;
     }
     return _deprecatedType;
   }
 
   @override
   InterfaceType get doubleType {
     if (_doubleType == null) {
       _initializeNumericTypes();
     }
     return _doubleType;
   }
 
   @override
   DartType get dynamicType {
     if (_dynamicType == null) {
       _dynamicType = DynamicTypeImpl.instance;
     }
     return _dynamicType;
   }
 
   @override
   InterfaceType get functionType {
     if (_functionType == null) {
-      _functionType = ElementFactory.classElement2("Function", []).type;
+      _functionType = ElementFactory.classElement2("Function").type;
     }
     return _functionType;
   }
 
   @override
   InterfaceType get intType {
     if (_intType == null) {
       _initializeNumericTypes();
     }
     return _intType;
@@ skipping 20 matching lines @@
       iteratorElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("current", false, eType)];
       _propagateTypeArguments(iteratorElement);
     }
     return _iteratorType;
   }
 
   @override
   InterfaceType get listType {
     if (_listType == null) {
       ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"]);
-      listElement.constructors = <ConstructorElement> [ElementFactory.constructorElement2(listElement, null, [])];
+      listElement.constructors = <ConstructorElement> [ElementFactory.constructorElement2(listElement, null)];
       _listType = listElement.type;
       DartType eType = listElement.typeParameters[0].type;
       InterfaceType iterableType = this.iterableType.substitute4(<DartType> [eType]);
       listElement.interfaces = <InterfaceType> [iterableType];
       listElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
       listElement.methods = <MethodElement> [
           ElementFactory.methodElement("[]", eType, [intType]),
           ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType]),
           ElementFactory.methodElement("add", VoidTypeImpl.instance, [eType])];
       _propagateTypeArguments(listElement);
@@ skipping 13 matching lines @@
           ElementFactory.methodElement("[]", vType, [objectType]),
           ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [kType, vType])];
       _propagateTypeArguments(mapElement);
     }
     return _mapType;
   }
 
   @override
   InterfaceType get nullType {
     if (_nullType == null) {
-      _nullType = ElementFactory.classElement2("Null", []).type;
+      _nullType = ElementFactory.classElement2("Null").type;
     }
     return _nullType;
   }
 
   @override
   InterfaceType get numType {
     if (_numType == null) {
       _initializeNumericTypes();
     }
     return _numType;
   }
 
   @override
   InterfaceType get objectType {
     if (_objectType == null) {
       ClassElementImpl objectElement = ElementFactory.object;
       _objectType = objectElement.type;
-      objectElement.constructors = <ConstructorElement> [ElementFactory.constructorElement2(objectElement, null, [])];
+      objectElement.constructors = <ConstructorElement> [ElementFactory.constructorElement2(objectElement, null)];
       objectElement.methods = <MethodElement> [
-          ElementFactory.methodElement("toString", stringType, []),
+          ElementFactory.methodElement("toString", stringType),
           ElementFactory.methodElement("==", boolType, [_objectType]),
           ElementFactory.methodElement("noSuchMethod", dynamicType, [dynamicType])];
       objectElement.accessors = <PropertyAccessorElement> [
           ElementFactory.getterElement("hashCode", false, intType),
           ElementFactory.getterElement("runtimeType", false, typeType)];
     }
     return _objectType;
   }
 
   @override
   InterfaceType get stackTraceType {
     if (_stackTraceType == null) {
-      _stackTraceType = ElementFactory.classElement2("StackTrace", []).type;
+      _stackTraceType = ElementFactory.classElement2("StackTrace").type;
     }
     return _stackTraceType;
   }
 
   @override
   InterfaceType get stringType {
     if (_stringType == null) {
-      _stringType = ElementFactory.classElement2("String", []).type;
+      _stringType = ElementFactory.classElement2("String").type;
       ClassElementImpl stringElement = _stringType.element as ClassElementImpl;
       stringElement.accessors = <PropertyAccessorElement> [
           ElementFactory.getterElement("isEmpty", false, boolType),
           ElementFactory.getterElement("length", false, intType),
           ElementFactory.getterElement("codeUnits", false, listType.substitute4(<DartType> [intType]))];
       stringElement.methods = <MethodElement> [
           ElementFactory.methodElement("+", _stringType, [_stringType]),
-          ElementFactory.methodElement("toLowerCase", _stringType, []),
-          ElementFactory.methodElement("toUpperCase", _stringType, [])];
-      ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(stringElement, "fromEnvironment", true, []);
+          ElementFactory.methodElement("toLowerCase", _stringType),
+          ElementFactory.methodElement("toUpperCase", _stringType)];
+      ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(stringElement, "fromEnvironment", true);
       fromEnvironment.parameters = <ParameterElement> [
           ElementFactory.requiredParameter2("name", stringType),
           ElementFactory.namedParameter2("defaultValue", _stringType)];
       fromEnvironment.factory = true;
       stringElement.constructors = <ConstructorElement> [fromEnvironment];
     }
     return _stringType;
   }
 
   @override
   InterfaceType get symbolType {
     if (_symbolType == null) {
-      ClassElementImpl symbolClass = ElementFactory.classElement2("Symbol", []);
+      ClassElementImpl symbolClass = ElementFactory.classElement2("Symbol");
       ConstructorElementImpl constructor = ElementFactory.constructorElement(symbolClass, null, true, [stringType]);
       constructor.factory = true;
       symbolClass.constructors = <ConstructorElement> [constructor];
       _symbolType = symbolClass.type;
     }
     return _symbolType;
   }
 
   @override
   InterfaceType get typeType {
     if (_typeType == null) {
-      _typeType = ElementFactory.classElement2("Type", []).type;
+      _typeType = ElementFactory.classElement2("Type").type;
     }
     return _typeType;
   }
 
   @override
   DartType get undefinedType {
     if (_undefinedType == null) {
       _undefinedType = UndefinedTypeImpl.instance;
     }
     return _undefinedType;
   }
 
   /**
    * Initialize the numeric types. They are created as a group so that we can (a) create the right
    * hierarchy and (b) add members to them.
    */
   void _initializeNumericTypes() {
     //
     // Create the type hierarchy.
     //
-    ClassElementImpl numElement = ElementFactory.classElement2("num", []);
+    ClassElementImpl numElement = ElementFactory.classElement2("num");
     _numType = numElement.type;
-    ClassElementImpl intElement = ElementFactory.classElement("int", _numType, []);
+    ClassElementImpl intElement = ElementFactory.classElement("int", _numType);
     _intType = intElement.type;
-    ClassElementImpl doubleElement = ElementFactory.classElement("double", _numType, []);
+    ClassElementImpl doubleElement = ElementFactory.classElement("double", _numType);
     _doubleType = doubleElement.type;
     //
     // Force the referenced types to be cached.
     //
     objectType;
     boolType;
     stringType;
     //
     // Add the methods.
     //
     numElement.methods = <MethodElement> [
         ElementFactory.methodElement("+", _numType, [_numType]),
         ElementFactory.methodElement("-", _numType, [_numType]),
         ElementFactory.methodElement("*", _numType, [_numType]),
         ElementFactory.methodElement("%", _numType, [_numType]),
         ElementFactory.methodElement("/", _doubleType, [_numType]),
         ElementFactory.methodElement("~/", _numType, [_numType]),
-        ElementFactory.methodElement("-", _numType, []),
+        ElementFactory.methodElement("-", _numType),
         ElementFactory.methodElement("remainder", _numType, [_numType]),
         ElementFactory.methodElement("<", _boolType, [_numType]),
         ElementFactory.methodElement("<=", _boolType, [_numType]),
         ElementFactory.methodElement(">", _boolType, [_numType]),
         ElementFactory.methodElement(">=", _boolType, [_numType]),
         ElementFactory.methodElement("==", _boolType, [_objectType]),
-        ElementFactory.methodElement("isNaN", _boolType, []),
-        ElementFactory.methodElement("isNegative", _boolType, []),
-        ElementFactory.methodElement("isInfinite", _boolType, []),
-        ElementFactory.methodElement("abs", _numType, []),
-        ElementFactory.methodElement("floor", _numType, []),
-        ElementFactory.methodElement("ceil", _numType, []),
-        ElementFactory.methodElement("round", _numType, []),
-        ElementFactory.methodElement("truncate", _numType, []),
-        ElementFactory.methodElement("toInt", _intType, []),
-        ElementFactory.methodElement("toDouble", _doubleType, []),
+        ElementFactory.methodElement("isNaN", _boolType),
+        ElementFactory.methodElement("isNegative", _boolType),
+        ElementFactory.methodElement("isInfinite", _boolType),
+        ElementFactory.methodElement("abs", _numType),
+        ElementFactory.methodElement("floor", _numType),
+        ElementFactory.methodElement("ceil", _numType),
+        ElementFactory.methodElement("round", _numType),
+        ElementFactory.methodElement("truncate", _numType),
+        ElementFactory.methodElement("toInt", _intType),
+        ElementFactory.methodElement("toDouble", _doubleType),
         ElementFactory.methodElement("toStringAsFixed", _stringType, [_intType]),
         ElementFactory.methodElement("toStringAsExponential", _stringType, [_intType]),
         ElementFactory.methodElement("toStringAsPrecision", _stringType, [_intType]),
         ElementFactory.methodElement("toRadixString", _stringType, [_intType])];
     intElement.methods = <MethodElement> [
         ElementFactory.methodElement("&", _intType, [_intType]),
         ElementFactory.methodElement("|", _intType, [_intType]),
         ElementFactory.methodElement("^", _intType, [_intType]),
-        ElementFactory.methodElement("~", _intType, []),
+        ElementFactory.methodElement("~", _intType),
         ElementFactory.methodElement("<<", _intType, [_intType]),
         ElementFactory.methodElement(">>", _intType, [_intType]),
-        ElementFactory.methodElement("-", _intType, []),
-        ElementFactory.methodElement("abs", _intType, []),
-        ElementFactory.methodElement("round", _intType, []),
-        ElementFactory.methodElement("floor", _intType, []),
-        ElementFactory.methodElement("ceil", _intType, []),
-        ElementFactory.methodElement("truncate", _intType, []),
-        ElementFactory.methodElement("toString", _stringType, [])];
-    ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(intElement, "fromEnvironment", true, []);
+        ElementFactory.methodElement("-", _intType),
+        ElementFactory.methodElement("abs", _intType),
+        ElementFactory.methodElement("round", _intType),
+        ElementFactory.methodElement("floor", _intType),
+        ElementFactory.methodElement("ceil", _intType),
+        ElementFactory.methodElement("truncate", _intType),
+        ElementFactory.methodElement("toString", _stringType)];
+    ConstructorElementImpl fromEnvironment = ElementFactory.constructorElement(intElement, "fromEnvironment", true);
     fromEnvironment.parameters = <ParameterElement> [
         ElementFactory.requiredParameter2("name", stringType),
         ElementFactory.namedParameter2("defaultValue", _intType)];
     fromEnvironment.factory = true;
     intElement.constructors = <ConstructorElement> [fromEnvironment];
     List<FieldElement> fields = <FieldElement> [
         ElementFactory.fieldElement("NAN", true, false, true, _doubleType),
         ElementFactory.fieldElement("INFINITY", true, false, true, _doubleType),
         ElementFactory.fieldElement("NEGATIVE_INFINITY", true, false, true, _doubleType),
         ElementFactory.fieldElement("MIN_POSITIVE", true, false, true, _doubleType),
         ElementFactory.fieldElement("MAX_FINITE", true, false, true, _doubleType)];
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
     doubleElement.methods = <MethodElement> [
         ElementFactory.methodElement("remainder", _doubleType, [_numType]),
         ElementFactory.methodElement("+", _doubleType, [_numType]),
         ElementFactory.methodElement("-", _doubleType, [_numType]),
         ElementFactory.methodElement("*", _doubleType, [_numType]),
         ElementFactory.methodElement("%", _doubleType, [_numType]),
         ElementFactory.methodElement("/", _doubleType, [_numType]),
         ElementFactory.methodElement("~/", _doubleType, [_numType]),
-        ElementFactory.methodElement("-", _doubleType, []),
-        ElementFactory.methodElement("abs", _doubleType, []),
-        ElementFactory.methodElement("round", _doubleType, []),
-        ElementFactory.methodElement("floor", _doubleType, []),
-        ElementFactory.methodElement("ceil", _doubleType, []),
-        ElementFactory.methodElement("truncate", _doubleType, []),
-        ElementFactory.methodElement("toString", _stringType, [])];
+        ElementFactory.methodElement("-", _doubleType),
+        ElementFactory.methodElement("abs", _doubleType),
+        ElementFactory.methodElement("round", _doubleType),
+        ElementFactory.methodElement("floor", _doubleType),
+        ElementFactory.methodElement("ceil", _doubleType),
+        ElementFactory.methodElement("truncate", _doubleType),
+        ElementFactory.methodElement("toString", _stringType)];
   }
 
   /**
    * Given a class element representing a class with type parameters, propagate those type
    * parameters to all of the accessors, methods and constructors defined for the class.
    *
    * @param classElement the element representing the class with type parameters
    */
   void _propagateTypeArguments(ClassElementImpl classElement) {
     List<DartType> typeArguments = TypeParameterTypeImpl.getTypes(classElement.typeParameters);
@@ skipping 45 matching lines @@
       manager.exitScope();
       fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
       // Expected
     }
   }
 
   void test_getType_enclosedOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
-    InterfaceType type = ElementFactory.classElement2("C", []).type;
+    InterfaceType type = ElementFactory.classElement2("C").type;
     manager.enterScope();
     manager.setType(element, type);
     manager.enterScope();
     expect(manager.getType(element), same(type));
   }
 
   void test_getType_immediateOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
-    InterfaceType type = ElementFactory.classElement2("C", []).type;
+    InterfaceType type = ElementFactory.classElement2("C").type;
     manager.enterScope();
     manager.setType(element, type);
     expect(manager.getType(element), same(type));
   }
 
   void test_getType_noOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
@@ skipping 1305 matching lines @@
   }
 }
 
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     //
     // Create a mock library element with the types expected to be in dart:core. We cannot use
     // either ElementFactory or TestTypeProvider (which uses ElementFactory) because we side-effect
     // the elements in ways that would break other tests.
     //
-    InterfaceType objectType = _classElement("Object", null, []).type;
-    InterfaceType boolType = _classElement("bool", objectType, []).type;
-    InterfaceType numType = _classElement("num", objectType, []).type;
-    InterfaceType doubleType = _classElement("double", numType, []).type;
-    InterfaceType functionType = _classElement("Function", objectType, []).type;
-    InterfaceType intType = _classElement("int", numType, []).type;
+    InterfaceType objectType = _classElement("Object", null).type;
+    InterfaceType boolType = _classElement("bool", objectType).type;
+    InterfaceType numType = _classElement("num", objectType).type;
+    InterfaceType doubleType = _classElement("double", numType).type;
+    InterfaceType functionType = _classElement("Function", objectType).type;
+    InterfaceType intType = _classElement("int", numType).type;
     InterfaceType listType = _classElement("List", objectType, ["E"]).type;
     InterfaceType mapType = _classElement("Map", objectType, ["K", "V"]).type;
-    InterfaceType stackTraceType = _classElement("StackTrace", objectType, []).type;
-    InterfaceType stringType = _classElement("String", objectType, []).type;
-    InterfaceType symbolType = _classElement("Symbol", objectType, []).type;
-    InterfaceType typeType = _classElement("Type", objectType, []).type;
+    InterfaceType stackTraceType = _classElement("StackTrace", objectType).type;
+    InterfaceType stringType = _classElement("String", objectType).type;
+    InterfaceType symbolType = _classElement("Symbol", objectType).type;
+    InterfaceType typeType = _classElement("Type", objectType).type;
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
     coreUnit.types = <ClassElement> [
         boolType.element,
         doubleType.element,
         functionType.element,
         intType.element,
         listType.element,
         mapType.element,
         objectType.element,
         stackTraceType.element,
@@ skipping 14 matching lines @@
     expect(provider.intType, same(intType));
     expect(provider.listType, same(listType));
     expect(provider.mapType, same(mapType));
     expect(provider.objectType, same(objectType));
     expect(provider.stackTraceType, same(stackTraceType));
     expect(provider.stringType, same(stringType));
     expect(provider.symbolType, same(symbolType));
     expect(provider.typeType, same(typeType));
   }
 
-  ClassElement _classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
+  ClassElement _classElement(String typeName, InterfaceType superclassType, [List<String> parameterNames]) {
     ClassElementImpl element = new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
     element.supertype = superclassType;
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element);
     element.type = type;
-    int count = parameterNames.length;
-    if (count > 0) {
-      List<TypeParameterElementImpl> typeParameters = new List<TypeParameterElementImpl>(count);
-      List<TypeParameterTypeImpl> typeArguments = new List<TypeParameterTypeImpl>(count);
-      for (int i = 0; i < count; i++) {
-        TypeParameterElementImpl typeParameter = new TypeParameterElementImpl.forNode(AstFactory.identifier3(parameterNames[i]));
-        typeParameters[i] = typeParameter;
-        typeArguments[i] = new TypeParameterTypeImpl(typeParameter);
-        typeParameter.type = typeArguments[i];
+    if (parameterNames != null) {
+      int count = parameterNames.length;
+      if (count > 0) {
+        List<TypeParameterElementImpl> typeParameters = new List<TypeParameterElementImpl>(count);
+        List<TypeParameterTypeImpl> typeArguments = new List<TypeParameterTypeImpl>(count);
+        for (int i = 0; i < count; i++) {
+          TypeParameterElementImpl typeParameter = new TypeParameterElementImpl.forNode(AstFactory.identifier3(parameterNames[i]));
+          typeParameters[i] = typeParameter;
+          typeArguments[i] = new TypeParameterTypeImpl(typeParameter);
+          typeParameter.type = typeArguments[i];
+        }
+        element.typeParameters = typeParameters;
+        type.typeArguments = typeArguments;
       }
-      element.typeParameters = typeParameters;
-      type.typeArguments = typeArguments;
     }
     return element;
   }
 }
 
 class TypeResolverVisitorTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
@@ skipping 39 matching lines @@
     _listener.assertNoErrors();
   }
 
   void fail_visitMethodDeclaration() {
     fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitVariableDeclaration() {
     fail("Not yet tested");
-    ClassElement type = ElementFactory.classElement2("A", []);
+    ClassElement type = ElementFactory.classElement2("A");
     VariableDeclaration node = AstFactory.variableDeclaration("a");
-    AstFactory.variableDeclarationList(null, AstFactory.typeName(type, []), [node]);
+    AstFactory.variableDeclarationList(null, AstFactory.typeName(type), [node]);
     //resolve(node);
     expect(node.name.staticType, same(type.type));
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
     SourceFactory factory = new SourceFactory([new FileUriResolver()]);
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = factory;
     Source librarySource = new FileBasedSource.con1(FileUtilities2.createFile("/lib.dart"));
     _library = new Library(context, _listener, librarySource);
     LibraryElementImpl element = new LibraryElementImpl.forNode(context, AstFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
     _typeProvider = new TestTypeProvider();
     _visitor = new TypeResolverVisitor.con1(_library, librarySource, _typeProvider);
     _implicitConstructorBuilder = new ImplicitConstructorBuilder.con1(_library, librarySource, _typeProvider);
   }
 
   void test_visitCatchClause_exception() {
     // catch (e)
-    CatchClause clause = AstFactory.catchClause("e", []);
+    CatchClause clause = AstFactory.catchClause("e");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl.forNode(exceptionParameter);
-    _resolveCatchClause(clause, _typeProvider.dynamicType, null, []);
+    _resolveCatchClause(clause, _typeProvider.dynamicType, null);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_exception_stackTrace() {
     // catch (e, s)
-    CatchClause clause = AstFactory.catchClause2("e", "s", []);
+    CatchClause clause = AstFactory.catchClause2("e", "s");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl.forNode(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement = new LocalVariableElementImpl.forNode(stackTraceParameter);
-    _resolveCatchClause(clause, _typeProvider.dynamicType, _typeProvider.stackTraceType, []);
+    _resolveCatchClause(clause, _typeProvider.dynamicType, _typeProvider.stackTraceType);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_on_exception() {
     // on E catch (e)
-    ClassElement exceptionElement = ElementFactory.classElement2("E", []);
-    TypeName exceptionType = AstFactory.typeName(exceptionElement, []);
-    CatchClause clause = AstFactory.catchClause4(exceptionType, "e", []);
+    ClassElement exceptionElement = ElementFactory.classElement2("E");
+    TypeName exceptionType = AstFactory.typeName(exceptionElement);
+    CatchClause clause = AstFactory.catchClause4(exceptionType, "e");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl.forNode(exceptionParameter);
     _resolveCatchClause(clause, exceptionElement.type, null, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
   void test_visitCatchClause_on_exception_stackTrace() {
     // on E catch (e, s)
-    ClassElement exceptionElement = ElementFactory.classElement2("E", []);
-    TypeName exceptionType = AstFactory.typeName(exceptionElement, []);
+    ClassElement exceptionElement = ElementFactory.classElement2("E");
+    TypeName exceptionType = AstFactory.typeName(exceptionElement);
     (exceptionType.name as SimpleIdentifier).staticElement = exceptionElement;
-    CatchClause clause = AstFactory.catchClause5(exceptionType, "e", "s", []);
+    CatchClause clause = AstFactory.catchClause5(exceptionType, "e", "s");
     SimpleIdentifier exceptionParameter = clause.exceptionParameter;
     exceptionParameter.staticElement = new LocalVariableElementImpl.forNode(exceptionParameter);
     SimpleIdentifier stackTraceParameter = clause.stackTraceParameter;
     stackTraceParameter.staticElement = new LocalVariableElementImpl.forNode(stackTraceParameter);
     _resolveCatchClause(clause, exceptionElement.type, _typeProvider.stackTraceType, [exceptionElement]);
     _listener.assertNoErrors();
   }
 
   void test_visitClassDeclaration() {
     // class A extends B with C implements D {}
     // class B {}
     // class C {}
     // class D {}
-    ClassElement elementA = ElementFactory.classElement2("A", []);
-    ClassElement elementB = ElementFactory.classElement2("B", []);
-    ClassElement elementC = ElementFactory.classElement2("C", []);
-    ClassElement elementD = ElementFactory.classElement2("D", []);
-    ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementB, []));
-    WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
-    ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
-    ClassDeclaration declaration = AstFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause, []);
+    ClassElement elementA = ElementFactory.classElement2("A");
+    ClassElement elementB = ElementFactory.classElement2("B");
+    ClassElement elementC = ElementFactory.classElement2("C");
+    ClassElement elementD = ElementFactory.classElement2("D");
+    ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementB));
+    WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC)]);
+    ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD)]);
+    ClassDeclaration declaration = AstFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause);
     declaration.name.staticElement = elementA;
     _resolveNode(declaration, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitClassDeclaration_instanceMemberCollidesWithClass() {
     // class A {}
     // class B extends A {
     //   void A() {}
     // }
-    ClassElementImpl elementA = ElementFactory.classElement2("A", []);
-    ClassElementImpl elementB = ElementFactory.classElement2("B", []);
-    elementB.methods = <MethodElement> [ElementFactory.methodElement("A", VoidTypeImpl.instance, [])];
-    ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementA, []));
-    ClassDeclaration declaration = AstFactory.classDeclaration(null, "B", null, extendsClause, null, null, []);
+    ClassElementImpl elementA = ElementFactory.classElement2("A");
+    ClassElementImpl elementB = ElementFactory.classElement2("B");
+    elementB.methods = <MethodElement> [ElementFactory.methodElement("A", VoidTypeImpl.instance)];
+    ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementA));
+    ClassDeclaration declaration = AstFactory.classDeclaration(null, "B", null, extendsClause, null, null);
     declaration.name.staticElement = elementB;
     _resolveNode(declaration, [elementA, elementB]);
     expect(elementB.supertype, same(elementA.type));
     _listener.assertNoErrors();
   }
 
   void test_visitClassTypeAlias() {
     // class A = B with C implements D;
-    ClassElement elementA = ElementFactory.classElement2("A", []);
-    ClassElement elementB = ElementFactory.classElement2("B", []);
-    ClassElement elementC = ElementFactory.classElement2("C", []);
-    ClassElement elementD = ElementFactory.classElement2("D", []);
-    WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
-    ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
-    ClassTypeAlias alias = AstFactory.classTypeAlias("A", null, null, AstFactory.typeName(elementB, []), withClause, implementsClause);
+    ClassElement elementA = ElementFactory.classElement2("A");
+    ClassElement elementB = ElementFactory.classElement2("B");
+    ClassElement elementC = ElementFactory.classElement2("C");
+    ClassElement elementD = ElementFactory.classElement2("D");
+    WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC)]);
+    ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD)]);
+    ClassTypeAlias alias = AstFactory.classTypeAlias("A", null, null, AstFactory.typeName(elementB), withClause, implementsClause);
     alias.name.staticElement = elementA;
     _resolveNode(alias, [elementA, elementB, elementC, elementD]);
     expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     expect(mixins, hasLength(1));
     expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     expect(interfaces, hasLength(1));
     expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_functionType() {
     InterfaceType intType = _typeProvider.intType;
-    TypeName intTypeName = AstFactory.typeName4("int", []);
+    TypeName intTypeName = AstFactory.typeName4("int");
     String innerParameterName = "a";
     SimpleFormalParameter parameter = AstFactory.simpleFormalParameter3(innerParameterName);
     parameter.identifier.staticElement = ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(null, intTypeName, outerParameterName, AstFactory.formalParameterList([parameter]));
     node.identifier.staticElement = ElementFactory.requiredParameter(outerParameterName);
     DartType parameterType = _resolveFormalParameter(node, [intType.element]);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionType, FunctionType, parameterType);
     FunctionType functionType = parameterType as FunctionType;
     expect(functionType.returnType, same(intType));
     expect(functionType.parameters, hasLength(1));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_noType() {
     String parameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(Keyword.VAR, null, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
-    expect(_resolveFormalParameter(node, []), same(_typeProvider.dynamicType));
+    expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_type() {
     InterfaceType intType = _typeProvider.intType;
-    TypeName intTypeName = AstFactory.typeName4("int", []);
+    TypeName intTypeName = AstFactory.typeName4("int");
     String parameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(null, intTypeName, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
     expect(_resolveFormalParameter(node, [intType.element]), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_noType() {
     // p
     FormalParameter node = AstFactory.simpleFormalParameter3("p");
     node.identifier.staticElement = new ParameterElementImpl.forNode(AstFactory.identifier3("p"));
-    expect(_resolveFormalParameter(node, []), same(_typeProvider.dynamicType));
+    expect(_resolveFormalParameter(node), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_type() {
     // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
-    FormalParameter node = AstFactory.simpleFormalParameter4(AstFactory.typeName(intElement, []), "p");
+    FormalParameter node = AstFactory.simpleFormalParameter4(AstFactory.typeName(intElement), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
     identifier.staticElement = element;
     expect(_resolveFormalParameter(node, [intElement]), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_noParameters_noArguments() {
-    ClassElement classA = ElementFactory.classElement2("A", []);
-    TypeName typeName = AstFactory.typeName(classA, []);
+    ClassElement classA = ElementFactory.classElement2("A");
+    TypeName typeName = AstFactory.typeName(classA);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(classA.type));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_parameters_arguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
-    ClassElement classB = ElementFactory.classElement2("B", []);
-    TypeName typeName = AstFactory.typeName(classA, [AstFactory.typeName(classB, [])]);
+    ClassElement classB = ElementFactory.classElement2("B");
+    TypeName typeName = AstFactory.typeName(classA, [AstFactory.typeName(classB)]);
     typeName.type = null;
     _resolveNode(typeName, [classA, classB]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(classB.type));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_parameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
-    TypeName typeName = AstFactory.typeName(classA, []);
+    TypeName typeName = AstFactory.typeName(classA);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     InterfaceType resultType = typeName.type as InterfaceType;
     expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], same(DynamicTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_void() {
-    ClassElement classA = ElementFactory.classElement2("A", []);
-    TypeName typeName = AstFactory.typeName4("void", []);
+    ClassElement classA = ElementFactory.classElement2("A");
+    TypeName typeName = AstFactory.typeName4("void");
     _resolveNode(typeName, [classA]);
     expect(typeName.type, same(VoidTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   /**
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
    * parameter.
    *
    * @param node the catch clause to be analyzed
    * @param exceptionType the expected type of the exception parameter
    * @param stackTraceType the expected type of the stack trace parameter
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    */
-  void _resolveCatchClause(CatchClause node, DartType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
+  void _resolveCatchClause(CatchClause node, DartType exceptionType, InterfaceType stackTraceType, [List<Element> definedElements]) {
     _resolveNode(node, definedElements);
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       expect(exceptionParameter.staticType, same(exceptionType));
     }
     SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
     if (stackTraceParameter != null) {
       expect(stackTraceParameter.staticType, same(stackTraceType));
     }
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
    *
    * @param node the parameter with which the type is associated
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the type associated with the parameter
    */
-  DartType _resolveFormalParameter(FormalParameter node, List<Element> definedElements) {
+  DartType _resolveFormalParameter(FormalParameter node, [List<Element> definedElements]) {
     _resolveNode(node, definedElements);
     return (node.identifier.staticElement as ParameterElement).type;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the element to which the expression was resolved
    */
-  void _resolveNode(AstNode node, List<Element> definedElements) {
-    for (Element element in definedElements) {
-      _library.libraryScope.define(element);
+  void _resolveNode(AstNode node, [List<Element> definedElements]) {
+    if (definedElements != null) {
+      for (Element element in definedElements) {
+        _library.libraryScope.define(element);
+      }
     }
     node.accept(_visitor);
     node.accept(_implicitConstructorBuilder);
   }
 }
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisDeltaTest);
   runReflectiveTests(ChangeSetTest);
@@ skipping 18 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }