Remove unnecessary List creation

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'dart:collection';
@@ skipping 1142 matching lines @@
               ListUtilities.addAll(errors, _getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
             }
           }
         }
       } on ObsoleteSourceAnalysisException catch (exception) {
         AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
-      return new List.from(errors);
+      return errors;
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       try {
         return _getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
       } on ObsoleteSourceAnalysisException catch (exception) {
         AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
     }
     return AnalysisError.NO_ERRORS;
   }
@@ skipping 201 matching lines @@
               htmlSources.add(iterator.key);
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
-    return new List.from(htmlSources);
+    return htmlSources;
   }
 
   @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
@@ skipping 10 matching lines @@
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
         //          }
       }
     }
-    return new List.from(sources);
+    return sources;
   }
 
   @override
   List<Source> get launchableServerLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that reference dart:html, either
     // directly or indirectly.
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
         //          }
       }
     }
-    return new List.from(sources);
+    return sources;
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.containingLibraries;
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry.kind == SourceKind.LIBRARY) {
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(iterator.key);
         }
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(iterator.key);
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
-    return new List.from(dependentLibraries);
+    return dependentLibraries;
   }
 
   @override
   List<Source> getLibrariesReferencedFromHtml(Source htmlSource) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
     }
     return Source.EMPTY_ARRAY;
@@ skipping 1895 matching lines @@
    * @return all of the sources known to this context that have the given kind
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.kind == kind) {
         sources.add(iterator.key);
       }
     }
-    return new List.from(sources);
+    return sources;
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. If so, add
    * the source to the set of sources that need to be processed. This method duplicates, and must
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
    * be used for testing purposes only.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
@@ skipping 1308 matching lines @@
             if (_taskData != null) {
               return;
             }
           }
         }
         if (importedLibrary != null) {
           importedLibraries.add(importedLibrary);
           _dependencyGraph.addEdge(library, importedLibrary);
         }
       }
-      library.importedLibraries = new List.from(importedLibraries);
+      library.importedLibraries = importedLibraries;
     } else {
       library.explicitlyImportsCore = false;
       ResolvableLibrary importedLibrary = _libraryMap[AnalysisContextImpl_this._coreLibrarySource];
       if (importedLibrary == null) {
         importedLibrary = _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource);
         if (importedLibrary != null) {
           _computeLibraryDependencies(importedLibrary);
           if (_taskData != null) {
             return;
           }
@@ skipping 17 matching lines @@
             if (_taskData != null) {
               return;
             }
           }
         }
         if (exportedLibrary != null) {
           exportedLibraries.add(exportedLibrary);
           _dependencyGraph.addEdge(library, exportedLibrary);
         }
       }
-      library.exportedLibraries = new List.from(exportedLibraries);
+      library.exportedLibraries = exportedLibraries;
     }
   }
 
   /**
    * Gather the resolvable AST structures for each of the compilation units in each of the
    * libraries in the cycle. This is done in two phases: first we ensure that we have cached an
    * AST structure for each compilation unit, then we gather them. We split the work this way
    * because getting the AST structures can change the state of the cache in such a way that we
    * would have more work to do if any compilation unit didn't have a resolvable AST structure.
    */
@@ skipping 335 matching lines @@
 
   HashSet<CaughtException> _exceptions = new HashSet<CaughtException>();
 
   List<AnalysisContextStatistics_PartitionData> _partitionData;
 
   void addSource(Source source) {
     _sources.add(source);
   }
 
   @override
-  List<AnalysisContextStatistics_CacheRow> get cacheRows {
-    Iterable<AnalysisContextStatistics_CacheRow> items = _dataMap.values;
-    return new List.from(items);
-  }
+  List<AnalysisContextStatistics_CacheRow> get cacheRows
+      => new List.from(_dataMap.values);

[scheglov, 2014/10/26 04:52:42]

Or just _dataMap.values.toList()

[sra1, 2014/10/26 06:31:39]

It is often better to use .toList() since it carries the generic type parameter
without having to write it.

[Brian Wilkerson, 2014/10/26 15:15:46]

Thanks! I was wondering whether there was a reason to choose one over the other.
I'll change this occurrence before committing, then I'll convert the rest in a
later CL.

 
   @override
   List<CaughtException> get exceptions => new List.from(_exceptions);
 
   @override
   List<AnalysisContextStatistics_PartitionData> get partitionData => _partitionData;
 
   @override
-  List<Source> get sources => new List.from(_sources);
+  List<Source> get sources => _sources;
 
   void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
     _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
   }
 
   void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
     _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
   }
 
   /**
@@ skipping 1606 matching lines @@
       } else if (startIndex + AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH < endIndex) {
         startIndex += AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH;
         AngularExpression expression = _parseAngularExpression(lexeme, startIndex, endIndex, offset);
         expressions.add(new AngularMoustacheXmlExpression(startIndex, endIndex, expression));
       }
       startIndex = StringUtilities.indexOf2(lexeme, endIndex + AngularMoustacheXmlExpression.CLOSING_DELIMITER_LENGTH, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR);
     }
   }
 
   void _parseEmbeddedExpressionsInAttribute(ht.XmlAttributeNode node) {
-    List<AngularMoustacheXmlExpression> expressions = [];
+    List<AngularMoustacheXmlExpression> expressions = <AngularMoustacheXmlExpression>[];
     _parseEmbeddedExpressions(expressions, node.valueToken);
     if (!expressions.isEmpty) {
-      node.expressions = new List.from(expressions);
+      node.expressions = expressions;
     }
   }
 
   void _parseEmbeddedExpressionsInTag(ht.XmlTagNode node) {
-    List<AngularMoustacheXmlExpression> expressions = [];
+    List<AngularMoustacheXmlExpression> expressions = <AngularMoustacheXmlExpression>[];
     ht.Token token = node.attributeEnd;
     ht.Token endToken = node.endToken;
     bool inChild = false;
     while (!identical(token, endToken)) {
       for (ht.XmlTagNode child in node.tagNodes) {
         if (identical(token, child.beginToken)) {
           inChild = true;
           break;
         }
         if (identical(token, child.endToken)) {
           inChild = false;
           break;
         }
       }
       if (!inChild && token.type == ht.TokenType.TEXT) {
         _parseEmbeddedExpressions(expressions, token);
       }
       token = token.next;
     }
-    node.expressions = new List.from(expressions);
+    node.expressions = expressions;
   }
 
   void _recordDefinedVariable(LocalVariableElementImpl variable) {
     _definedVariables.add(variable);
     _functionElement.localVariables = new List.from(_definedVariables);
   }
 
   /**
    * When we inject variable, we give access to the library of its type.
    */
@@ skipping 50 matching lines @@
     // define formatters
     for (AngularElement angularElement in angularElements) {
       if (angularElement is AngularFormatterElement) {
         _defineTopVariable_forClassElement(angularElement);
       }
     }
     // run this HTML visitor
     _unit.accept(this);
     // simulate imports for injects
     {
-      List<ImportElement> imports = [];
+      List<ImportElement> imports = <ImportElement>[];
       for (LibraryElement injectedLibrary in _injectedLibraries) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = injectedLibrary;
         imports.add(importElement);
       }
-      _libraryElement.imports = new List.from(imports);
+      _libraryElement.imports = imports;
     }
   }
 
   void _resolveXmlExpression(AngularXmlExpression angularXmlExpression) {
     AngularExpression angularExpression = angularXmlExpression.expression;
     _resolveExpression(angularExpression);
   }
 
   List<Token> _splitAtBar(Token token) {
     List<Token> tokens = [];
@@ skipping 1086 matching lines @@
     while (state != null) {
       errors.addAll(state.getValue(RESOLUTION_ERRORS));
       errors.addAll(state.getValue(VERIFICATION_ERRORS));
       errors.addAll(state.getValue(HINTS));
       state = state._nextState;
     }
     errors.addAll(getValue(ANGULAR_ERRORS));
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
-    return new List.from(errors);
+    return errors;
   }
 
   /**
    * Return a valid parsed compilation unit, either an unresolved AST structure
    * or the result of resolving the AST structure in the context of some library,
    * or `null` if there is no parsed compilation unit available.
    */
   CompilationUnit get anyParsedCompilationUnit {
     if (getState(PARSED_UNIT) == CacheState.VALID) {
       return getValue(PARSED_UNIT);
@@ skipping 37 matching lines @@
    */
   List<Source> get librariesContaining {
     ResolutionState state = _resolutionState;
     List<Source> result = new List<Source>();
     while (state != null) {
       if (state._librarySource != null) {
         result.add(state._librarySource);
       }
       state = state._nextState;
     }
-    return new List.from(result);
+    return result;
   }
 
   /**
    * A compilation unit that has not been accessed by any other client and can
    * therefore safely be modified by the reconciler, or `null` if the source has
    * not been parsed.
    */
   CompilationUnit get resolvableCompilationUnit {
     if (getState(PARSED_UNIT) == CacheState.VALID) {
       CompilationUnit unit = getValue(PARSED_UNIT);
@@ skipping 3305 matching lines @@
           nameOffset = textOffset + index - 1;
         }
         nameBuilder.appendChar(c);
       }
       if (nameOffset != -1) {
         nameTokens.add(new PolymerHtmlUnitBuilder_NameToken(nameOffset, nameBuilder.toString()));
         nameBuilder = new JavaStringBuilder();
       }
     }
     // create attributes for name tokens
-    List<PolymerAttributeElement> attributes = [];
+    List<PolymerAttributeElement> attributes = <PolymerAttributeElement>[];
     Set<String> definedNames = new Set();
     ClassElement classElement = _dartElement.classElement;
     for (PolymerHtmlUnitBuilder_NameToken nameToken in nameTokens) {
       int offset = nameToken._offset;
       // prepare name
       String name = nameToken._value;
       if (!isValidAttributeName(name)) {
         _reportErrorForNameToken(nameToken, PolymerCode.INVALID_ATTRIBUTE_NAME, [name]);
         continue;
       }
       if (!definedNames.add(name)) {
         _reportErrorForNameToken(nameToken, PolymerCode.DUPLICATE_ATTRIBUTE_DEFINITION, [name]);
         continue;
       }
       // create attribute
       PolymerAttributeElementImpl attribute = new PolymerAttributeElementImpl(name, offset);
       attributes.add(attribute);
       // resolve field
       FieldElement field = classElement.getField(name);
       if (field == null) {
         _reportErrorForNameToken(nameToken, PolymerCode.UNDEFINED_ATTRIBUTE_FIELD, [name, classElement.displayName]);
         continue;
       }
       if (!_isPublishedField(field)) {
         _reportErrorForNameToken(nameToken, PolymerCode.ATTRIBUTE_FIELD_NOT_PUBLISHED, [name, classElement.displayName]);
       }
       attribute.field = field;
     }
-    _htmlElement.attributes = new List.from(attributes);
+    _htmlElement.attributes = attributes;
   }
 
   void _createTagHtmlElement(ht.XmlTagNode node) {
     this._elementNode = node;
     this._elementName = null;
     this._htmlElement = null;
     this._dartElement = null;
     // prepare 'name' attribute
     ht.XmlAttributeNode nameAttribute = node.getAttribute("name");
     if (nameAttribute == null) {
@@ skipping 257 matching lines @@
   List<AnalysisError> get errors {
     Iterable<MapEntry<Source, HashSet<AnalysisError>>> entrySet = getMapEntrySet(_errors);
     int numEntries = entrySet.length;
     if (numEntries == 0) {
       return AnalysisError.NO_ERRORS;
     }
     List<AnalysisError> resultList = new List<AnalysisError>();
     for (MapEntry<Source, HashSet<AnalysisError>> entry in entrySet) {
       resultList.addAll(entry.getValue());
     }
-    return new List.from(resultList);
+    return resultList;
   }
 
   /**
    * Answer the errors collected by the listener for some passed [Source].
    *
    * @param source some [Source] for which the caller wants the set of [AnalysisError]s
    *          collected by this listener
    * @return the errors collected by the listener for the passed [Source]
    */
   List<AnalysisError> getErrorsForSource(Source source) {
@@ skipping 1822 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }