Remove unnecessary List creation

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 1284 matching lines @@
     _toolkitObjects = ArrayUtils.add(_toolkitObjects, toolkitObject);
   }
 
   @override
   List<PropertyAccessorElement> get accessors => _accessors;
 
   @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
-    return new List.from(list);
+    return list;
   }
 
   @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have thrown a CCE if any of
     // the elements in the arrays were not of the expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
@@ skipping 2452 matching lines @@
    *
    * @param element the element whose location is being represented
    */
   ElementLocationImpl.con1(Element element) {
     List<String> components = new List<String>();
     Element ancestor = element;
     while (ancestor != null) {
       components.insert(0, (ancestor as ElementImpl).identifier);
       ancestor = ancestor.enclosingElement;
     }
-    this._components = new List.from(components);
+    this._components = components;
   }
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
     this._components = _decode(encoding);
   }
@@ skipping 79 matching lines @@
           components.add(builder.toString());
           builder.length = 0;
           index++;
         }
       } else {
         builder.appendChar(currentChar);
         index++;
       }
     }
     components.add(builder.toString());
-    return new List.from(components);
+    return components;
   }
 
   /**
    * Append an encoded form of the given component to the given builder.
    *
    * @param builder the builder to which the encoded component is to be appended
    * @param component the component to be appended to the builder
    */
   void _encode(JavaStringBuilder builder, String component) {
     int length = component.length;
@@ skipping 1534 matching lines @@
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.REQUIRED) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
           type = type.substitute2(typeArguments, typeParameters);
         }
         types.add(type);
       }
     }
-    return new List.from(types);
+    return types;
   }
 
   @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (parameter.parameterKind == ParameterKind.POSITIONAL) {
         DartType type = parameter.type;
         if (typeArguments.length != 0 && typeArguments.length == typeParameters.length) {
           type = type.substitute2(typeArguments, typeParameters);
         }
         types.add(type);
       }
     }
-    return new List.from(types);
+    return types;
   }
 
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     // no parameters, quick return
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
@@ skipping 2451 matching lines @@
 
   @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
     int count = _imports.length;
     List<ImportElement> importList = new List<ImportElement>();
     for (int i = 0; i < count; i++) {
       if (identical(_imports[i].prefix, prefixElement)) {
         importList.add(_imports[i]);
       }
     }
-    return new List.from(importList);
+    return importList;
   }
 
   @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
   LibraryElement get library => this;
 
   @override
   FunctionElement get loadLibraryFunction {
@@ skipping 3379 matching lines @@
 
   @override
   int get hashCode => _types.hashCode;
 
   @override
   DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     List<DartType> out = new List<DartType>();
     for (DartType t in _types) {
       out.add(t.substitute2(argumentTypes, parameterTypes));
     }
-    return union(new List.from(out));
+    return union(out);
   }
 
   @override
   void appendTo(JavaStringBuilder builder) {
     String prefix = "{";
     for (DartType t in _types) {
       builder.append(prefix);
       (t as TypeImpl).appendTo(builder);
       prefix = ",";
     }
@@ skipping 435 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }