Implement most of String API.

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');
 
 /**
   * Returns true if both arguments are numbers.
@@ skipping 182 matching lines @@
 }
 
 neg(var a) {
   if (JS("bool", @"typeof $0 === 'number'", a)) return JS("num", @"-$0", a);
   return UNINTERCEPTED(-a);
 }
 
 index(var a, var index) {
   checkNull(a);
   if (a is String || isJSArray(a)) {
-    if (!(index is int)) {
-      throw new IllegalArgumentException(index);
+    if (index is !int) {
+      if (index is !num) throw new IllegalArgumentException(index);

[ngeoffray, 2012/02/21 09:45:37]

Why not checkNum?

+      if (index.truncate() !== index) throw new IllegalArgumentException(index);

[ngeoffray, 2012/02/21 09:45:37]

What's this about?

     }
     if (index < 0 || index >= a.length) {
       throw new IndexOutOfRangeException(index);
     }
     return JS("Object", @"$0[$1]", a, index);
   }
   return UNINTERCEPTED(a[index]);
 }
 
 indexSet(var a, var index, var value) {
@@ skipping 91 matching lines @@
   bool hasNext() => i < JS("int", @"$0.length", list);
   T next() {
     if (!hasNext()) throw new NoMoreElementsException();
     var value = JS("Object", @"$0[$1]", list, i);
     i += 1;
     return value;
   }
 }
 
 builtin$charCodeAt$1(var receiver, int index) {
+  checkNull(receiver);

[ngeoffray, 2012/02/21 09:45:37]

No need for check null

   if (receiver is String) {
+    if (index is !num) throw new IllegalArgumentException(index);

[ngeoffray, 2012/02/21 09:45:37]

Why not checkNum?

+    if (index < 0) throw new IndexOutOfRangeException(index);
+    if (index >= receiver.length) throw new IndexOutOfRangeException(index);
     return JS("string", @"$0.charCodeAt($1)", receiver, index);
   } else {
     return UNINTERCEPTED(receiver.charCodeAt(index));
   }
 }
 
 builtin$isEmpty$0(var receiver) {
   checkNull(receiver);
   if (receiver is String || isJSArray(receiver)) {
     return JS("bool", @"$0.length === 0", receiver);
@@ skipping 60 matching lines @@
   static int getMinutes(int secondsSinceEpoch, bool isUtc) {
     throw 'Primitives.getMinutes is not implemented';
   }
 
   static int getSeconds(int secondsSinceEpoch, bool isUtc) {
     throw 'Primitives.getSeconds is not implemented';
   }
 
   static String stringFromCharCodes(charCodes) {
     for (var i in charCodes) {
-      checkNum(i);
+      if (i is !int) throw new IllegalArgumentException(i);

[ngeoffray, 2012/02/21 09:45:37]

Why not checkInt?

     }
     return JS('String', @'String.fromCharCode.apply($0, $1)', null, charCodes);
   }
 }
 
 builtin$compareTo$1(a, b) {
   checkNull(a);
   if (checkNumbers(a, b, 'illegal argument')) {
     if (a < b) {
       return -1;
@@ skipping 10 matching lines @@
       return 0;
     } else if (a.isNaN()) {
       if (b.isNaN()) {
         return 0;
       }
       return 1;
     } else {
       return -1;
     }
   } else if (a is String) {
-    throw 'String.compareTo is not implemented';
+    if (b is !String) throw new IllegalArgumentException(b);

[ngeoffray, 2012/02/21 09:45:37]

checkString?

+    return (a === b) ? 0 : JS('bool', @'$0 < $1', a, b) ? -1 : 1;

[kasperl, 2012/02/20 10:44:51]

Shouldn't this be (a == b)?

[ahe, 2012/02/20 16:31:58]

Not sure. Perhaps I should use JS('bool', '$0 == $1', a, b) instead. This way it
is clearer this is an "optimization".

   } else {
     return UNINTERCEPTED(a.compareTo(b));
   }
 }
 
 iae(argument) {
   throw new IllegalArgumentException(argument);
 }
 
 ioore(index) {
@@ skipping 59 matching lines @@
   return UNINTERCEPTED(receiver.indexOf(element));
 }
 
 builtin$indexOf$2(receiver, element, start) {
   checkNull(receiver);
   if (isJSArray(receiver)) {
     if (start is !int) throw new IllegalArgumentException(start);
     var length = JS("num", @"$0.length", receiver);
     return Arrays.indexOf(receiver, element, start, length);
   } else if (receiver is String) {
-    throw new NotImplementedException();
+    checkNull(element);

[ngeoffray, 2012/02/21 09:45:37]

No need for check null

+    if (start is !int) throw new IllegalArgumentException(start);

[ngeoffray, 2012/02/21 09:45:37]

checkInt, checkString?

+    if (element is !String) throw new IllegalArgumentException(element);
+    if (start < 0) return -1; // TODO(ahe): Is this correct?
+    return JS('int', @'$0.indexOf($1, $2)', receiver, element, start);
   }
   return UNINTERCEPTED(receiver.indexOf(element, start));
 }
 
 builtin$insertRange$2(receiver, start, length) {
   checkNull(receiver);
   if (isJSArray(receiver)) {
     return builtin$insertRange$3(receiver, start, length, null);
   }
   return UNINTERCEPTED(receiver.insertRange(start, length));
@@ skipping 42 matching lines @@
   }
   return receiver[receiver.length - 1];
 }
 
 builtin$lastIndexOf$1(receiver, element) {
   checkNull(receiver);
   if (isJSArray(receiver)) {
     var start = JS("num", @"$0.length", receiver);
     return Arrays.lastIndexOf(receiver, element, start);
   } else if (receiver is String) {
-    throw new NotImplementedException();
+    checkNull(element);

[ngeoffray, 2012/02/21 09:45:37]

No need.

+    if (element is !String) throw new IllegalArgumentException(element);
+    return JS('int', @'$0.lastIndexOf($1)', receiver, element);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element));
 }
 
 builtin$lastIndexOf$2(receiver, element, start) {
   checkNull(receiver);
   if (isJSArray(receiver)) {
     return Arrays.lastIndexOf(receiver, element, start);
   } else if (receiver is String) {
-    throw new NotImplementedException();
+    checkNull(element);

[ngeoffray, 2012/02/21 09:45:37]

No need.

+    if (element is !String) throw new IllegalArgumentException(element);
+    if (start !== null) {
+      if (start is !num) throw new IllegalArgumentException(start);
+      if (start < 0) return -1;
+      if (start >= receiver.length) start = receiver.length - 1;
+    }
+    return rawStringLastIndexOf(receiver, element, start);
   }
   return UNINTERCEPTED(receiver.lastIndexOf(element, start));
 }
 
+rawStringLastIndexOf(receiver, element, start)
+  => JS('int', @'$0.lastIndexOf($1, $2)', receiver, element, start);
+
 builtin$removeRange$2(receiver, start, length) {
   checkNull(receiver);
   if (!isJSArray(receiver)) {
     return UNINTERCEPTED(receiver.removeRange(start, length));
   }
   if (length == 0) {
     return;
   }
   checkNull(start); // TODO(ahe): This is not specified but co19 tests it.
   checkNull(length); // TODO(ahe): This is not specified but co19 tests it.
@@ skipping 205 matching lines @@
   }
   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 new NotImplementedException();
+  throw 'String.allMatches is not implemented';
 }
 
 builtin$concat$1(receiver, other) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.concat(other));
 
-  throw new NotImplementedException();
+  if (other is !String) throw new IllegalArgumentException(other);
+  return JS('String', @'$0.concat($1)', receiver, other);
 }
 
 builtin$contains$2(receiver, other, startIndex) {
   checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.contains(other, startIndex));
   }
-
-  throw new NotImplementedException();
+  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;
 }
 
 builtin$endsWith$1(receiver, other) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.endsWith(other));
 
-  throw new NotImplementedException();
+  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 new NotImplementedException();
+  throw 'String.replaceAll is not implemented';
 }
 
 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);

[kasperl, 2012/02/20 10:44:51]

Duplicate line. Did you want to check to too?

[ahe, 2012/02/20 16:31:58]

Done.

+  if (from is !String) throw new IllegalArgumentException(from);
 
-  throw new NotImplementedException();
+  return JS('String', @'$0.replace($1, $2)', 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);
 
-  throw new NotImplementedException();
+  return JS('List', @'$0.split($1)', receiver, pattern);
 }
 
 builtin$splitChars$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.splitChars());
 
-  throw new NotImplementedException();
+  return JS('List', @'$0.split("")', receiver);
 }
 
 builtin$startsWith$1(receiver, other) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.startsWith(other));
+  checkNull(other);
+  if (other is !String) throw new IllegalArgumentException(other);
 
-  throw new NotImplementedException();
+  int length = other.length;
+  if (length > receiver.length) return false;
+  return other === JS('String', @'$0.substring(0, $1)', receiver, length);

[kasperl, 2012/02/20 10:44:51]

== rather than ===

[ahe, 2012/02/20 16:31:58]

Using JS.

 }
 
 builtin$substring$1(receiver, startIndex) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.substring(startIndex));
 
-  throw new NotImplementedException();
+  return builtin$substring$2(receiver, startIndex, null);
 }
 
 builtin$substring$2(receiver, startIndex, endIndex) {
   checkNull(receiver);
   if (receiver is !String) {
     return UNINTERCEPTED(receiver.substring(startIndex, endIndex));
   }
+  checkNum(startIndex);
+  var length = receiver.length;
+  if (endIndex === null) endIndex = length;
+  checkNum(endIndex);
+  if (startIndex < 0 ) throw new IndexOutOfRangeException(startIndex);
+  if (startIndex > endIndex) throw new IndexOutOfRangeException(startIndex);
+  if (endIndex > length) throw new IndexOutOfRangeException(endIndex);
+  return substringUnchecked(receiver, startIndex, endIndex);
+}
 
-  throw new NotImplementedException();
-}
+substringUnchecked(receiver, startIndex, endIndex)

[kasperl, 2012/02/20 10:44:51]

You're using rawXxx for some methods and xxxUnchecked for others?

[ahe, 2012/02/20 16:31:58]

Done.

+  => JS('String', @'$0.substring($1, $2)', receiver, startIndex, endIndex);
+
 
 builtin$toLowerCase$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.toLowerCase());
 
-  throw new NotImplementedException();
+  return JS('String', @'$0.toLowerCase()', receiver);
 }
 
 builtin$toUpperCase$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.toUpperCase());
 
-  throw new NotImplementedException();
+  return JS('String', @'$0.toUpperCase()', receiver);
 }
 
 builtin$trim$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.trim());
 
   return JS('String', @'$0.trim()', receiver);
 }
 
 class MathNatives {
@@ skipping 52 matching lines @@
     checkNum(exponent);
     return JS("num", @"Math.pow($0, $1)", value, exponent);
   }
 
   static double random() => JS("double", @"Math.random()");
 }
 
 builtin$hashCode$0(receiver) {
   if (receiver is num) return receiver & 0x1FFFFFFF;
   if (receiver is String) {
-    throw new NotImplementedException();
+    throw 'String.hashCode is not implemented';
   }
   if (isJSArray(receiver)) {
-    throw new NotImplementedException();
+    throw 'List.hashCode is not implemented';
   }
   return UNINTERCEPTED(receiver.hashCode());
 }