Optimize _GrowableArray._join and _StringBase._interpolate.

runtime/lib/growable_array.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.
 
 class _GrowableList<T> implements List<T> {
 
   void insert(int index, T element) {
     if ((index < 0) || (index > length)) {
       throw new RangeError.range(index, 0, length);
     }
@@ skipping 239 matching lines @@
 
   void forEach(f(T element)) {
     int initialLength = length;
     for (int i = 0; i < length; i++) {
       f(this[i]);
       if (length != initialLength) throw new ConcurrentModificationError(this);
     }
   }
 
   String join([String separator = ""]) {
-    if (isEmpty) return "";
-    if (this.length == 1) return "${this[0]}";
+    final int length = this.length;
+    if (length == 0) return "";
+    if (length == 1) return "${this[0]}";
+    if (separator.isNotEmpty) return _joinWithSeparator(separator);
+    var i = 0;
+    var codeUnitCount = 0;
+    while (i < length) {
+      final element = this[i];
+      final int cid = ClassID.getID(element);
+      // While list contains one-byte strings.
+      if (ClassID.cidOneByteString == cid) {
+        codeUnitCount += element.length;
+        i++;
+        continue;
+      }
+      final int firstNonOneByteStringLimit = i;
+      var nextElement = element;
+      while (nextElement is String) {

[Ivan Posva, 2014/09/16 14:57:32]

Please add comments where appropriate that this is not really a while loop over
i at the most outer level.

There are many internal continuations of the loop. As far as I can tell quickly
once you get here, you will not go back to the top of the loop. If that is the
case you should state that.

[Lasse Reichstein Nielsen, 2014/09/18 09:30:37]

Done.

+        i++;
+        if (i == length) {
+          return _StringBase._concatRangeNative(this, 0, length);
+        }
+        nextElement = this[i];
+      }
+      final list = new _List(length);
+      for (int copyIndex = 0; copyIndex < i; copyIndex++) {
+        list[copyIndex] = this[copyIndex];
+      }
+      // Is non-zero if list contains a non-onebyte string.
+      var onebyteCanary = i - firstNonOneByteStringLimit;
+      while (true) {
+        final String element = "$nextElement";

[Ivan Posva, 2014/09/16 14:57:32]

Shadowing element makes this inner loop even more confusing.

[Lasse Reichstein Nielsen, 2014/09/18 09:30:37]

Renamed to elementString.

+        onebyteCanary |= (ClassID.getID(element) ^ ClassID.cidOneByteString);
+        list[i] = element;
+        codeUnitCount += element.length;
+        i++;
+        if (i == length) break;
+        nextElement = this[i];
+      }
+      if (onebyteCanary == 0) {
+        // All elements returned a one-byte string from toString.
+        return _OneByteString._concatAll(list, codeUnitCount);
+      }
+      return _StringBase._concatRangeNative(list, 0, length);

[Ivan Posva, 2014/09/16 14:57:32]

Might want to pass codeUnitCount? We already know it here.

[Lasse Reichstein Nielsen, 2014/09/18 09:30:37]

We probably always have that information, or could have it, when using
_concatRangeNative, so adding an extra argument sounds like a good idea.

+    }
+    // All elements were one-byte strings.
+    return _OneByteString._concatAll(this, codeUnitCount);
+  }
+
+  String _joinWithSeparator(String separator) {
     StringBuffer buffer = new StringBuffer();
-    if (separator.isEmpty) {
-      for (int i = 0; i < this.length; i++) {
-        buffer.write(this[i]);
-      }
-    } else {
-      buffer.write(this[0]);
-      for (int i = 1; i < this.length; i++) {
-        buffer.write(separator);
-        buffer.write(this[i]);
-      }
+    buffer.write(this[0]);
+    for (int i = 1; i < this.length; i++) {
+      buffer.write(separator);
+      buffer.write(this[i]);
     }
     return buffer.toString();
   }
 
   Iterable map(f(T element)) {
     return IterableMixinWorkaround.mapList(this, f);
   }
 
   T reduce(T combine(T value, T element)) {
     return IterableMixinWorkaround.reduce(this, combine);
@@ skipping 94 matching lines @@
   }
 
   Set<T> toSet() {
     return new Set<T>.from(this);
   }
 
   Map<int, T> asMap() {
     return new IterableMixinWorkaround<T>().asMapList(this);
   }
 }