Add optimized _OneByteString.toLowerCase.

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);
   }
 
   /* patch */ const factory String.fromEnvironment(String name,
@@ skipping 760 matching lines @@
     } else {
       for (int i = 0; i < delta; i++) {
         for (int j = 0; j < padLength; j++) {
           result._setAt(index++, padding.codeUnitAt(j));
         }
       }
     }
     return result;
   }
 
+  int _nextLowerCase(int offset) {

[Søren Gjesse, 2014/03/25 15:28:05]

Shouldn't this be called _nextUpperCase/_nextUpperCaseiNDEX?

+    final length = this.length;
+    while (offset < length) {
+      int codeUnit = this.codeUnitAt(offset);

[srdjan, 2014/03/25 15:46:31]

final codeUnit

+      if (((codeUnit - 0x41) & 0xff) < 26) {
+        // Optimzed ASCII check:

[srdjan, 2014/03/25 15:46:31]

s/Optimzed/Optimized/

+        //  -  0x41 is 'A'
+        //  -  0xff is LATIN1 mask
+        //  -  26 is the number of characters in this range.
+        return offset;
+      } else if ((((codeUnit - 0xc0) & 0xff) < 32) && codeUnit != 0xd7) {
+        // Optimzed remaining LATIN1 check:

[srdjan, 2014/03/25 15:46:31]

ditto

+        //  -  0xc0 is first character > 127
+        //  -  0xff is LATIN1 mask
+        //  -  32 is the number of characters in this range.
+        //  -  0xd7 is an exception in the this range.
+        return offset;
+      }
+      offset++;
+    }
+    return -1;
+  }
+
+  String toLowerCase() {
+    int next = _nextLowerCase(0);
+    if (next == -1) return this;
+    final length = this.length;
+    _OneByteString result = _OneByteString._allocate(length);
+    int offset = 0;
+    do {
+      // Copy all up to the next one.
+      while (offset < next) {
+        result._setAt(offset, this.codeUnitAt(offset));
+        offset++;
+      }
+      // 0x20 is the delta between lower and upper, in both ranges. It's
+      // possible to 'or' instead of 'add', due to the layout.
+      result._setAt(offset, this.codeUnitAt(offset) | 0x20);

[srdjan, 2014/03/25 15:46:31]

What is the advantage of using OR instead of ADD? 

[Anders Johnsen, 2014/03/25 19:35:50]

No need for SMI overflow checks?

+      offset++;
+      next = _nextLowerCase(offset);
+    } while (next != -1);
+    // Remaining characters.
+    while (offset < length) {
+      result._setAt(offset, this.codeUnitAt(offset));
+      offset++;
+    }
+    return result;

[sra1, 2014/03/25 16:00:33]

In the case of a one character string, the VM might have an invariant that the
'character' strings are canonicalized.  (V8 does this for ascii)

What makes me think this is line 233.
You might need to return result[0] when length==1

[Anders Johnsen, 2014/03/25 19:35:50]

Done.

+
+  }
+
   // Allocates a string of given length, expecting its content to be
   // set using _setAt.
   static _OneByteString _allocate(int length) native "OneByteString_allocate";
 
 
   static _OneByteString _allocateFromOneByteList(List<int> list)
       native "OneByteString_allocateFromOneByteList";
 
   // This is internal helper method. Code point value must be a valid
   // Latin1 value (0..0xFF), index must be valid.
@@ skipping 90 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);
 }