Create fewer unnecessary lists

pkg/analyzer/test/generated/engine_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.engine_test;
 
 import 'dart:collection';
@@ skipping 1990 matching lines @@
 class DartEntryTest extends EngineTestCase {
   void test_allErrors() {
     Source source = new TestSource();
     DartEntry entry = new DartEntry();
     expect(entry.allErrors, hasLength(0));
     entry.setValue(
         DartEntry.SCAN_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
-                ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-                [])]);
+                ScannerErrorCode.UNTERMINATED_STRING_LITERAL)]);
     entry.setValue(
         DartEntry.PARSE_ERRORS,
         <AnalysisError>[
-            new AnalysisError.con1(source, ParserErrorCode.ABSTRACT_CLASS_MEMBER, [])]);
+            new AnalysisError.con1(source, ParserErrorCode.ABSTRACT_CLASS_MEMBER)]);
     entry.setValueInLibrary(
         DartEntry.RESOLUTION_ERRORS,
         source,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
-                CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION,
-                [])]);
+                CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)]);
     entry.setValueInLibrary(
         DartEntry.VERIFICATION_ERRORS,
         source,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
-                StaticWarningCode.CASE_BLOCK_NOT_TERMINATED,
-                [])]);
+                StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)]);
     entry.setValueInLibrary(
         DartEntry.ANGULAR_ERRORS,
         source,
-        <AnalysisError>[new AnalysisError.con1(source, AngularCode.MISSING_NAME, [])]);
+        <AnalysisError>[new AnalysisError.con1(source, AngularCode.MISSING_NAME)]);
     entry.setValueInLibrary(
         DartEntry.HINTS,
         source,
-        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
+        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE)]);
     expect(entry.allErrors, hasLength(5));
   }
 
   void test_creation() {
     Source librarySource = new TestSource();
     DartEntry entry = new DartEntry();
     expect(entry.getState(SourceEntry.CONTENT), same(CacheState.INVALID));
     expect(entry.getState(SourceEntry.LINE_INFO), same(CacheState.INVALID));
     expect(entry.getState(DartEntry.CONTAINING_LIBRARIES), same(CacheState.INVALID));
     expect(entry.getState(DartEntry.ELEMENT), same(CacheState.INVALID));
@@ skipping 21 matching lines @@
   void test_getResolvableCompilationUnit_none() {
     DartEntry entry = new DartEntry();
     expect(entry.resolvableCompilationUnit, isNull);
   }
 
   void test_getResolvableCompilationUnit_parsed_accessed() {
     Source librarySource = new TestSource("/lib.dart");
     String importUri = "/f1.dart";
     Source importSource = new TestSource(importUri);
     ImportDirective importDirective =
-        AstFactory.importDirective3(importUri, null, []);
+        AstFactory.importDirective3(importUri, null);
     importDirective.source = importSource;
     importDirective.uriContent = importUri;
     String exportUri = "/f2.dart";
     Source exportSource = new TestSource(exportUri);
     ExportDirective exportDirective =
-        AstFactory.exportDirective2(exportUri, []);
+        AstFactory.exportDirective2(exportUri);
     exportDirective.source = exportSource;
     exportDirective.uriContent = exportUri;
     String partUri = "/f3.dart";
     Source partSource = new TestSource(partUri);
     PartDirective partDirective = AstFactory.partDirective2(partUri);
     partDirective.source = partSource;
     partDirective.uriContent = partUri;
     CompilationUnit unit =
         AstFactory.compilationUnit3([importDirective, exportDirective, partDirective]);
     DartEntry entry = new DartEntry();
@@ skipping 20 matching lines @@
     CompilationUnit unit = AstFactory.compilationUnit();
     DartEntry entry = new DartEntry();
     entry.setValue(DartEntry.PARSED_UNIT, unit);
     expect(entry.resolvableCompilationUnit, same(unit));
   }
 
   void test_getResolvableCompilationUnit_resolved() {
     String importUri = "f1.dart";
     Source importSource = new TestSource(importUri);
     ImportDirective importDirective =
-        AstFactory.importDirective3(importUri, null, []);
+        AstFactory.importDirective3(importUri, null);
     importDirective.source = importSource;
     importDirective.uriContent = importUri;
     String exportUri = "f2.dart";
     Source exportSource = new TestSource(exportUri);
     ExportDirective exportDirective =
-        AstFactory.exportDirective2(exportUri, []);
+        AstFactory.exportDirective2(exportUri);
     exportDirective.source = exportSource;
     exportDirective.uriContent = exportUri;
     String partUri = "f3.dart";
     Source partSource = new TestSource(partUri);
     PartDirective partDirective = AstFactory.partDirective2(partUri);
     partDirective.source = partSource;
     partDirective.uriContent = partUri;
     CompilationUnit unit =
         AstFactory.compilationUnit3([importDirective, exportDirective, partDirective]);
     DartEntry entry = new DartEntry();
@@ skipping 821 matching lines @@
         new LibraryElementImpl.forNode(null, AstFactory.libraryIdentifier2(["lib"])));
   }
 
   void test_setValue_exportedLibraries() {
     _setValue(DartEntry.EXPORTED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_hints() {
     _setValueInLibrary(
         DartEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE, [])]);
+        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE)]);
   }
 
   void test_setValue_importedLibraries() {
     _setValue(DartEntry.IMPORTED_LIBRARIES, <Source>[new TestSource()]);
   }
 
   void test_setValue_includedParts() {
     _setValue(DartEntry.INCLUDED_PARTS, <Source>[new TestSource()]);
   }
 
   void test_setValue_isClient() {
     _setValue(DartEntry.IS_CLIENT, true);
   }
 
   void test_setValue_isLaunchable() {
     _setValue(DartEntry.IS_LAUNCHABLE, true);
   }
 
   void test_setValue_lineInfo() {
     _setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0]));
   }
 
   void test_setValue_parseErrors() {
     _setValue(
         DartEntry.PARSE_ERRORS,
         <AnalysisError>[
-            new AnalysisError.con1(null, ParserErrorCode.ABSTRACT_CLASS_MEMBER, [])]);
+            new AnalysisError.con1(null, ParserErrorCode.ABSTRACT_CLASS_MEMBER)]);
   }
 
   void test_setValue_parsedUnit() {
     _setValue(DartEntry.PARSED_UNIT, AstFactory.compilationUnit());
   }
 
   void test_setValue_publicNamespace() {
     _setValue(
         DartEntry.PUBLIC_NAMESPACE,
         new Namespace(new HashMap<String, Element>()));
   }
 
   void test_setValue_resolutionErrors() {
     _setValueInLibrary(
         DartEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(
                 null,
-                CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION,
-                [])]);
+                CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION)]);
   }
 
   void test_setValue_resolvedUnit() {
     _setValueInLibrary(DartEntry.RESOLVED_UNIT, AstFactory.compilationUnit());
   }
 
   void test_setValue_scanErrors() {
     _setValue(
         DartEntry.SCAN_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(
                 null,
-                ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT,
-                [])]);
+                ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT)]);
   }
 
   void test_setValue_sourceKind() {
     _setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
   }
 
   void test_setValue_tokenStream() {
     _setValue(DartEntry.TOKEN_STREAM, new Token(TokenType.LT, 5));
   }
 
   void test_setValue_verificationErrors() {
     _setValueInLibrary(
         DartEntry.VERIFICATION_ERRORS,
         <AnalysisError>[
-            new AnalysisError.con1(null, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, [])]);
+            new AnalysisError.con1(null, StaticWarningCode.CASE_BLOCK_NOT_TERMINATED)]);
   }
 
   DartEntry _entryWithValidState([Source firstLibrary, Source secondLibrary]) {
     DartEntry entry = new DartEntry();
     entry.setValue(SourceEntry.CONTENT, null);
     entry.setValue(SourceEntry.LINE_INFO, null);
     entry.setValue(DartEntry.CONTAINING_LIBRARIES, null);
     entry.setValue(DartEntry.ELEMENT, null);
     entry.setValue(DartEntry.EXPORTED_LIBRARIES, null);
     entry.setValue(DartEntry.IMPORTED_LIBRARIES, null);
@@ skipping 432 matching lines @@
     entry.setValue(
         HtmlEntry.POLYMER_BUILD_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.POLYMER_RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
+        <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE)]);
     expect(entry.allErrors, hasLength(6));
   }
 
   void test_invalidateAllResolutionInformation() {
     HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
     expect(entry.getState(HtmlEntry.ANGULAR_APPLICATION), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.ANGULAR_COMPONENT), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.ANGULAR_ENTRY), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.ANGULAR_ERRORS), same(CacheState.INVALID));
@@ skipping 73 matching lines @@
             new AnalysisError.con1(null, AngularCode.INVALID_REPEAT_SYNTAX, ["-"])]);
   }
 
   void test_setValue_element() {
     _setValue(HtmlEntry.ELEMENT, new HtmlElementImpl(null, "test.html"));
   }
 
   void test_setValue_hints() {
     _setValue(
         HtmlEntry.HINTS,
-        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE, [])]);
+        <AnalysisError>[new AnalysisError.con1(null, HintCode.DEAD_CODE)]);
   }
 
   void test_setValue_illegal() {
     HtmlEntry entry = new HtmlEntry();
     try {
       entry.setValue(DartEntry.ELEMENT, null);
       fail("Expected IllegalArgumentException for DartEntry.ELEMENT");
     } on ArgumentError catch (exception) {
     }
   }
@@ skipping 1313 matching lines @@
   ParseDartTaskTestTV_perform_validateDirectives(this.context, this.source);
   @override
   Object visitParseDartTask(ParseDartTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.compilationUnit, isNotNull);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     errorListener.addAll(task.errors);
-    errorListener.assertErrorsWithCodes(
-        [
-            CompileTimeErrorCode.URI_WITH_INTERPOLATION,
-            CompileTimeErrorCode.INVALID_URI]);
+    errorListener.assertErrorsWithCodes([
+        CompileTimeErrorCode.URI_WITH_INTERPOLATION,
+        CompileTimeErrorCode.INVALID_URI]);
     expect(task.source, same(source));
     expect(task.hasNonPartOfDirective, isTrue);
     expect(task.hasPartOfDirective, isFalse);
     return null;
   }
 }
 
 
 class ParseHtmlTaskTest extends EngineTestCase {
   ParseHtmlTask parseContents(String contents, TestLogger testLogger) {
@@ skipping 332 matching lines @@
     ResolveDartUnitTask task =
         new ResolveDartUnitTask(context, source, element);
     task.perform(new ResolveDartUnitTaskTestTV_perform_exception());
   }
 
   void test_perform_library() {
     InternalAnalysisContext context = AnalysisContextFactory.contextWithCore();
     LibraryElementImpl libraryElement = ElementFactory.library(context, "lib");
     CompilationUnitElementImpl unitElement =
         libraryElement.definingCompilationUnit as CompilationUnitElementImpl;
-    ClassElementImpl classElement = ElementFactory.classElement2("A", []);
+    ClassElementImpl classElement = ElementFactory.classElement2("A");
     classElement.nameOffset = 19;
     ConstructorElementImpl constructorElement =
-        ElementFactory.constructorElement2(classElement, null, []);
+        ElementFactory.constructorElement2(classElement, null);
     constructorElement.synthetic = true;
     classElement.constructors = <ConstructorElement>[constructorElement];
     unitElement.types = <ClassElement>[classElement];
     Source source = unitElement.source;
     context.setContents(
         source,
         r'''
 library lib;
 class A {}''');
     ResolveDartUnitTask task =
@@ skipping 1431 matching lines @@
   }
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }