Use growable lists.

dart/sdk/lib/_internal/compiler/implementation/mirrors_used.dart

 // Copyright (c) 2013, 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 dart2js.mirrors_used;
 
 import 'dart2jslib.dart' show
     Compiler,
     CompilerTask,
     Constant,
@@ skipping 129 matching lines @@
           new ConstantMapper(compiler.constantHandler, mapping, compiler);
       named.expression.accept(mapper);
 
       MirrorUsageBuilder builder =
           new MirrorUsageBuilder(
               analyzer, mapping.currentElement.getLibrary(), named.expression,
               value, mapper.constantToNodeMap);
 
       if (named.name.source == 'symbols') {
         analyzer.cachedStrings[value] =
-            builder.convertToListOfStrings(
-                builder.convertConstantToUsageList(value, onlyStrings: true));
+            builder.convertConstantToUsageList(value, onlyStrings: true);
       } else if (named.name.source == 'targets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'metaTargets') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       } else if (named.name.source == 'override') {
         analyzer.cachedElements[value] =
             builder.resolveUsageList(builder.convertConstantToUsageList(value));
       }
@@ skipping 221 matching lines @@
       this.spannable,
       this.constant,
       this.constantToNodeMap);
 
   Compiler get compiler => analyzer.compiler;
 
   /// Convert a constant to a list of [String] and [Type] values. If the
   /// constant is a single [String], it is assumed to be a comma-separated list
   /// of qualified names. If the constant is a [Type] t, the result is [:[t]:].
   /// Otherwise, the constant is assumed to represent a list of strings (each a
-  /// qualified name) and types, and such a list is constructed.
+  /// qualified name) and types, and such a list is constructed.  If
+  /// [onlyStrings] is true, the returned list is a [:List<String>:] and any
+  /// [Type] values are treated as an error (meaning that the value is ignored
+  /// and a hint is emitted).
   List convertConstantToUsageList(
       Constant constant, { bool onlyStrings: false }) {
     if (constant.isNull()) {
       return null;
     } else if (constant.isList()) {
       ListConstant list = constant;
-      List result = [];
+      List result = onlyStrings ? <String> [] : [];
       for (Constant entry in list.entries) {
         if (entry.isString()) {
           StringConstant string = entry;
           result.add(string.value.slowToString());
         } else if (!onlyStrings && entry.isType()) {
           TypeConstant type = entry;
           result.add(type.representedType);
         } else {
           Spannable node = positionOf(entry);
           MessageKind kind = onlyStrings
               ? MessageKind.MIRRORS_EXPECTED_STRING
               : MessageKind.MIRRORS_EXPECTED_STRING_OR_TYPE;
           compiler.reportHint(
               node,
               kind, {'name': node, 'type': apiTypeOf(entry)});
         }
       }
       return result;
     } else if (!onlyStrings && constant.isType()) {
       TypeConstant type = constant;
       return [type.representedType];
     } else if (constant.isString()) {
       StringConstant string = constant;
-      return
-          string.value.slowToString().split(',').map((e) => e.trim()).toList();
+      var iterable =
+          string.value.slowToString().split(',').map((e) => e.trim());
+      return onlyStrings ? new List<String>.from(iterable) : iterable.toList();
     } else {
       Spannable node = positionOf(constant);
       MessageKind kind = onlyStrings
           ? MessageKind.MIRRORS_EXPECTED_STRING_OR_LIST
           : MessageKind.MIRRORS_EXPECTED_STRING_TYPE_OR_LIST;
       compiler.reportHint(
           node,
           kind, {'name': node, 'type': apiTypeOf(constant)});
       return null;
     }
   }
 
   /// Find the first non-implementation interface of constant.
   DartType apiTypeOf(Constant constant) {
     DartType type = constant.computeType(compiler);
     LibraryElement library = type.element.getLibrary();
     if (type.kind == TypeKind.INTERFACE && library.isInternalLibrary) {
       InterfaceType interface = type;
       ClassElement cls = type.element;
       for (DartType supertype in cls.ensureResolved(compiler).allSupertypes) {
         if (supertype.kind == TypeKind.INTERFACE
             && !supertype.element.getLibrary().isInternalLibrary) {
           return interface.asInstanceOf(supertype.element);
         }
       }
     }
     return type;
   }
 
-  /// Ensure a list contains only strings.
-  List<String> convertToListOfStrings(List list) {
-    if (list == null) return null;
-    List<String> result = new List<String>(list.length);
-    int count = 0;
-    for (var entry in list) {
-      assert(invariant(spannable, entry is String));
-      result[count++] = entry;
-    }
-    return result;
-  }
-
   /// Convert a list of strings and types to a list of elements. Types are
   /// converted to their corresponding element, and strings are resolved as
   /// follows:
   ///
   /// First find the longest library name that is a prefix of the string, if
   /// there are none, resolve using [resolveExpression]. Otherwise, resolve the
   /// rest of the string using [resolveLocalExpression].
   List<Element> resolveUsageList(List list) {
     if (list == null) return null;
     if (list.length == 1 && list[0] == '*') {
@@ skipping 114 matching lines @@
       // @MirrorsUsed(targets: fisk)
       //                       ^^^^
       //
       // Instead of saying 'fisk' should pretty print the problematic constant
       // value.
       return spannable;
     }
     return node;
   }
 }