Improve String and RegExp implementations.

dart/frog/leg/lib/js_helper.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.
 
 #library('js_helper');
 
 #import('coreimpl.dart');
 
 #source('date_helper.dart');
 #source('regexp_helper.dart');
+#source('string_helper.dart');
 
 /**
   * Returns true if both arguments are numbers.
   * If only the first argument is a number, throws the given message as
   * exception.
   */
 bool checkNumbers(var a, var b, var message) {
   if (a is num) {
     if (b is num) {
       return true;
@@ skipping 920 matching lines @@
     return UNINTERCEPTED(receiver.toRadixString(radix));
   }
   checkNum(radix);
 
   return JS("String", @"$0.toString($1)", receiver, radix);
 }
 
 builtin$allMatches$1(receiver, str) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.allMatches(str));
-
-  throw 'String.allMatches is not implemented';
+  checkString(str);
+  return allMatchesInStringUnchecked(receiver, str);
 }
 
 builtin$concat$1(receiver, other) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.concat(other));
 
   if (other is !String) throw new IllegalArgumentException(other);
   return JS('String', @'$0.concat($1)', receiver, other);
 }
 
+builtin$contains$1(receiver, other) {
+  if (receiver is !String) {
+    checkNull(receiver);
+    return UNINTERCEPTED(receiver.contains(other));
+  }
+  return builtin$contains$2(receiver, other, 0);
+}
+
 builtin$contains$2(receiver, other, startIndex) {
   checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.contains(other, startIndex));
   }
   checkNull(other);
-  if (other is !String) {
-    throw 'String.contains with non-String is not implemented';
-  }
-  if ((startIndex !== null) && (startIndex is !num)) {
-    throw new IllegalArgumentException(startIndex);
-  }
-  return receiver.indexOf(other, startIndex) >= 0;
+  return stringContainsUnchecked(receiver, other, startIndex);
 }
 
 builtin$endsWith$1(receiver, other) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.endsWith(other));
 
   checkNull(other);
   if (other is !String) throw new IllegalArgumentException(other);
 
   int receiverLength = receiver.length;
   int otherLength = other.length;
   if (otherLength > receiverLength) return false;
   return other == receiver.substring(receiverLength - otherLength);
 }
 
 builtin$replaceAll$2(receiver, from, to) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.replaceAll(from, to));
 
-  throw 'String.replaceAll is not implemented';
+  checkNull(from);
+  checkString(to);
+  return stringReplaceAllUnchecked(receiver, from, to);
 }
 
 builtin$replaceFirst$2(receiver, from, to) {
   checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.replaceFirst(from, to));
   }
-  if (from is !String) throw new IllegalArgumentException(from);
-  if (to is !String) throw new IllegalArgumentException(to);
-
-  return JS('String', @'$0.replace($1, $2)', receiver, from, to);
+  checkNull(from);
+  checkString(to);
+  return stringReplaceFirstUnchecked(receiver, from, to);
 }
 
 builtin$split$1(receiver, pattern) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.split(pattern));
   checkNull(pattern);
-  if (pattern is !String) throw new IllegalArgumentException(pattern);
-
-  return JS('List', @'$0.split($1)', receiver, pattern);
+  return stringSplitUnchecked(receiver, pattern);
 }
 
 builtin$splitChars$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.splitChars());
 
   return JS('List', @'$0.split("")', receiver);
 }
 
 builtin$startsWith$1(receiver, other) {
@@ skipping 118 matching lines @@
 builtin$hashCode$0(receiver) {
   if (receiver is num) return receiver & 0x1FFFFFFF;
   if (receiver is String) {
     throw 'String.hashCode is not implemented';
   }
   if (isJsArray(receiver)) {
     throw 'List.hashCode is not implemented';
   }
   return UNINTERCEPTED(receiver.hashCode());
 }