Use strict when possible. Don't even try to cache the hashcode for strings.

compiler/lib/implementation/string.js

 // Copyright (c) 2011, 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.
 
 function native_StringImplementation__indexOperator(index) {
+  "use strict";
   return this[index];
 }
 
 function native_StringImplementation__charCodeAt(index) {
+  "use strict";
   return this.charCodeAt(index);
 }
 
 function native_StringImplementation_get$length() {
+  "use strict";
   return this.length;
 }
 
 function native_StringImplementation_EQ(other) {
+  "use strict";
   return typeof other == 'string' && this == other;
 }
 
 function native_StringImplementation__nativeIndexOf(other, startIndex) {
+  "use strict";
   return this.indexOf(other, startIndex);
 }
 
 function native_StringImplementation__nativeLastIndexOf(other, fromIndex) {
+  "use strict";
   if (other == "") {
     return Math.min(this.length, fromIndex);
   }
   return this.lastIndexOf(other, fromIndex);
 }
 
 function native_StringImplementation_concat(other) {
+  "use strict";
   return this.concat(other);
 }
 
 function native_StringImplementation__substringUnchecked(startIndex, endIndex) {
+  "use strict";
   return this.substring(startIndex, endIndex);
 }
 
 function native_StringImplementation_trim() {
+  "use strict";
   if (this.trim) return this.trim();
   return this.replace(new RegExp("^[\s]+|[\s]+$", "g"), "");
 }
 
 function native_StringImplementation__replace(from, to) {
+  "use strict";
   if ($isString(from)) {
     return this.replace(from, to);
   } else {
     return this.replace($DartRegExpToJSRegExp(from), to);
   }
 }
 
 function native_StringImplementation__replaceAll(from, to) {
+  "use strict";
   if ($isString(from)) {
     var regexp = new RegExp(
         from.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), 'g');
     return this.replace(regexp, to);
   } else {
     var regexp = $DartRegExpToJSRegExp(from);
     return this.replace(regexp, to);
   }
 }
 
 function native_StringImplementation__split(pattern) {
+  "use strict";
   if ($isString(pattern)) {
     return this.split(pattern);
   } else {
     return this.split($DartRegExpToJSRegExp(pattern));
   }
 }
 
 function native_StringImplementation_toLowerCase() {
+  "use strict";
   return this.toLowerCase();
 }
 
 function native_StringImplementation_toUpperCase() {
+  "use strict";
   return this.toUpperCase();
 }
 
 // Inherited from Hashable.
 function native_StringImplementation_hashCode() {
-  if (this.hash_ === undefined) {
-    for (var i = 0; i < this.length; i++) {
-      var ch = this.charCodeAt(i);
-      this.hash_ += ch;
-      this.hash_ += this.hash_ << 10;
-      this.hash_ ^= this.hash_ >> 6;
-    }
+  "use strict";

[sra1, 2011/11/22 18:13:39]

What is the benefit of "use strict" in this and the other functions?  Does it
make a measurable performance improvement?

[floitsch, 2011/11/23 09:21:54]

"use strict" doesn't wrap the object. So (3).hashCode() will not go through the
boxing.
Iirc we saw a *5 improvement on the raytracer (that some external user submitted
to the mailing list a long time ago).

+  var hash = 0;
+  for (var i = 0; i < this.length; i++) {
+    var ch = this.charCodeAt(i);
+    hash += ch;
+    hash += hash << 10;

[sra1, 2011/11/22 18:13:39]

The result of += can be outside the 32-bit range of << and ^= leading to boxing.
 I think this loop needs to be carefully rewritten so that the common browsers
all are fast.

I'm wondering where this hash function originated, and if we intend to define
the hash code of a string.

[floitsch, 2011/11/23 09:21:54]

Given that we can't store the hash we should rethink our hashing strategy
anyways.
Maybe open a bug?

+    hash ^= hash >> 6;
+  }
 
-    this.hash_ += this.hash_ << 3;
-    this.hash_ ^= this.hash_ >> 11;
-    this.hash_ += this.hash_ << 15;
-    this.hash_ = this.hash_ & ((1 << 29) - 1);
-  }
-  return this.hash_;
+  hash += hash << 3;
+  hash ^= hash >> 11;
+  hash += hash << 15;
+  hash = hash & ((1 << 29) - 1);
+
+  return hash;
 }
 
 function native_StringImplementation_toString() {
+  "use strict";
   // Return the primitive string of this String object.
   return String(this);
 }
 
 // TODO(floitsch): If we allow comparison operators on the String class we
 // should move this function into dart world.
 function native_StringImplementation_compareTo(other) {
+  "use strict";
   if (this == other) return 0;
   if (this < other) return -1;
   return 1;
 }
 
 function native_StringImplementation__newFromValues(array) {
+  "use strict";
   if (!(array instanceof Array)) {
     var length = native__ListJsUtil__listLength(array);
     var tmp = new Array(length);
     for (var i = 0; i < length; i++) {
       tmp[i] = INDEX$operator(array, i);
     }
     array = tmp;
   }
   return String.fromCharCode.apply(this, array);
 }
 
 // Deprecated old name of new String.fromValues(..).
 function native_StringBase_createFromCharCodes(array) {
   return native_StringImplementation__newFromValues(array);
 }