Implement string.trim for dart2js.

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

Index: sdk/lib/_internal/compiler/implementation/lib/js_string.dart
diff --git a/sdk/lib/_internal/compiler/implementation/lib/js_string.dart b/sdk/lib/_internal/compiler/implementation/lib/js_string.dart
index 56a494daee63d7b666ce7fea20fa0e0b46946e91..a1470753c61f8951a83589f0617887035b388860 100644
--- a/sdk/lib/_internal/compiler/implementation/lib/js_string.dart
+++ b/sdk/lib/_internal/compiler/implementation/lib/js_string.dart
@@ -97,8 +97,90 @@ class JSString extends Interceptor implements String, JSIndexable {
     return JS('String', r'#.toUpperCase()', this);
   }
 
+  // Characters with Whitespace property (Unicode 6.2).
+  // 0009..000D    ; White_Space # Cc       <control-0009>..<control-000D>
+  // 0020          ; White_Space # Zs       SPACE
+  // 0085          ; White_Space # Cc       <control-0085>
+  // 00A0          ; White_Space # Zs       NO-BREAK SPACE
+  // 1680          ; White_Space # Zs       OGHAM SPACE MARK
+  // 180E          ; White_Space # Zs       MONGOLIAN VOWEL SEPARATOR
+  // 2000..200A    ; White_Space # Zs       EN QUAD..HAIR SPACE
+  // 2028          ; White_Space # Zl       LINE SEPARATOR
+  // 2029          ; White_Space # Zp       PARAGRAPH SEPARATOR
+  // 202F          ; White_Space # Zs       NARROW NO-BREAK SPACE
+  // 205F          ; White_Space # Zs       MEDIUM MATHEMATICAL SPACE
+  // 3000          ; White_Space # Zs       IDEOGRAPHIC SPACE
+  //
+  // BOM: 0xFEFF
+  bool _isWhitespace(int codeUnit) {

[sra1, 2013/05/22 22:39:03]

static?

[floitsch, 2013/05/23 12:52:50]

Done.

+    switch (codeUnit) {
+      case 0x09:
+      case 0x0A:
+      case 0x0B:
+      case 0x0C:
+      case 0x0D:
+      case 0x20:
+      case 0x85:
+      case 0xA0:
+      case 0x1680:
+      case 0x180E:
+      case 0x2000:
+      case 0x2001:
+      case 0x2002:
+      case 0x2003:
+      case 0x2004:
+      case 0x2005:
+      case 0x2006:
+      case 0x2007:
+      case 0x2008:
+      case 0x2009:
+      case 0x200A:
+      case 0x2028:
+      case 0x2029:
+      case 0x202F:
+      case 0x205F:
+      case 0x3000:
+      case 0xFEFF:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  // Dart2js can't use JavaScript trim, because JavaScript does not trim
+  // the New-line character (0x85).

[sra1, 2013/05/22 22:39:03]

I believe it is called NEXT LINE, not new-line.  Comment could also say JS trim
does not trim BOM aka deprecated Zero-width no-break space.

JavaScript trim *can* be used provided the string does not contain a trimable
NEXT LINE or BOM (or see below, possibly NBSP)
You could call trim() and then fall through if the result starts or ends with
0x85 or 0xFEFF.  That would avoid >50 comparisons from the switch statement in
common cases (it fails once at each end of the string in the current
implementation).

[floitsch, 2013/05/23 12:52:50]

yes. NEXT LINE.
I don't see how the native trim function can avoid the comparisons. Also: the
switch is transformed into a JS switch. JS engines can optimize them.
Nevertheless split the _isWhitespace into <256 and >=256 parts.

   String trim() {

[sra1, 2013/05/22 22:39:03]

Can't this whole operation be coded concisely with a JavaScript regex match?

Example:
http://closure-library.googlecode.com/svn/docs/closure_goog_string_string.js....

goog.string.trim = function(str) {
  // Since IE doesn't include non-breaking-space (0xa0) in their \s character
  // class (as required by section 7.2 of the ECMAScript spec), we explicitly
  // include it in the regexp to enforce consistent cross-browser behavior.
  return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
};

[floitsch, 2013/05/23 12:52:50]

The regexp will run in squared behavior for trimming the end-characters. It is
also currently not supported by dart2js (which doesn't want to see \x and \u in
JS regexps).

I tried to use the native trim function (uploaded a patch), but in the end it
wasn't really smaller.

-    return JS('String', r'#.trim()', this);
+    const int CARRIAGE_RETURN = 0x0D;
+    const int SPACE = 0x20;
+
+    int startIndex = 0;
+    while (startIndex < this.length) {
+      int codeUnit = this.codeUnitAt(startIndex);
+      if (codeUnit == SPACE ||
+          codeUnit == CARRIAGE_RETURN ||
+          _isWhitespace(codeUnit)) {
+        startIndex++;
+      } else {
+        break;
+      }
+    }
+    if (startIndex == this.length) return "";
+
+    int endIndex = this.length;
+    // We know that there is at least one character that is non-whitespace.
+    // Therefore we don't need to verify that endIndex > startIndex.
+    while (true) {
+      int codeUnit = this.codeUnitAt(endIndex - 1);
+      if (codeUnit == SPACE ||
+          codeUnit == CARRIAGE_RETURN ||
+          _isWhitespace(codeUnit)) {
+        endIndex--;
+      } else {
+        break;
+      }
+    }
+    if (startIndex == 0 && endIndex == this.length) return this;
+    return JS('String', r'#.substring(#, #)', this, startIndex, endIndex);
   }
 
   List<int> get codeUnits => new _CodeUnits(this);