Do not copy immutable arrays in String.createFromCharCodes. Tighten the types a little in string_pa…

runtime/lib/string_patch.dart

 // Copyright (c) 2012, 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.
 
 patch class String {
   /* patch */ factory String.fromCharCodes(Iterable<int> charCodes) {
     return _StringBase.createFromCharCodes(charCodes);
   }
 }
 
 
 /**
  * [_StringBase] contains common methods used by concrete String
  * implementations, e.g., _OneByteString.
  */
 class _StringBase {
 
   factory _StringBase._uninstantiable() {
     throw new UnsupportedError(
         "_StringBase can't be instaniated");
   }
 
   int get hashCode native "String_getHashCode";
 
   /**
    *  Create the most efficient string representation for specified
    *  [codePoints].
    */
   static String createFromCharCodes(Iterable<int> charCodes) {
-    if (charCodes is! _ObjectArray && charCodes is! _GrowableObjectArray) {
+    // TODO(srdjan): Also skip copying of typed arrays.
+    if (charCodes is! _ObjectArray &&

[Ivan Posva, 2013/05/03 15:44:27]

This will not work long-term. Especially once we have "implements dynamic". What
we really need to do in the library implementations is have access to the
classId and check for those, as the VM implementation of the libraries is an
extension of the VM C++ code.

[srdjan, 2013/05/03 16:44:47]

Good point. What is the ETA for "implements dynamic". All "is" and "as" in VM
Dart libraries need to be checked and eventually replaced with a class-id check.

I will implement a direct class check and convert VM library code to use it.

+        charCodes is! _GrowableObjectArray &&
+        charCodes is! _ImmutableArray) {
       charCodes = new List<int>.from(charCodes, growable: false);
     }
+
     return _createFromCodePoints(charCodes);
   }
 
   static String _createFromCodePoints(List<int> codePoints)
       native "StringBase_createFromCodePoints";
 
   String operator [](int index) native "String_charAt";
 
   int codeUnitAt(int index) native "String_codeUnitAt";
 
@@ skipping 264 matching lines @@
     return buffer.toString();
   }
 
 
   /**
    * Convert all objects in [values] to strings and concat them
    * into a result string.
    */
   static String _interpolate(List values) {
     int numValues = values.length;
-    var stringList = new List(numValues);
+    _ObjectArray stringList = new List(numValues);
     for (int i = 0; i < numValues; i++) {
       stringList[i] = values[i].toString();
     }
     return _concatAll(stringList);
   }
 
   Iterable<Match> allMatches(String str) {
     List<Match> result = new List<Match>();
     int length = str.length;
     int patternLength = this.length;
@@ skipping 93 matching lines @@
       stringsArray = new _ObjectArray(len);
       int i = 0;
       for (String string in strings) {
         if (string is! String) throw new ArgumentError(string);
         stringsArray[i++] = string;
       }
     }
     return _concatAll(stringsArray);
   }
 
-  static String _concatAll(List<String> strings)
+  static String _concatAll(_ObjectArray<String> strings)
       native "Strings_concatAll";
 }
 
 
 class _OneByteString extends _StringBase implements String {
   factory _OneByteString._uninstantiable() {
     throw new UnsupportedError(
         "_OneByteString can only be allocated by the VM");
   }
 
@@ skipping 143 matching lines @@
 class _CodeUnits extends Object with ListMixin<int>,
                                      UnmodifiableListMixin<int> {
   /** The string that this is the code units of. */
   String _string;
 
   _CodeUnits(this._string);
 
   int get length => _string.length;
   int operator[](int i) => _string.codeUnitAt(i);
 }