Add JsArray

sdk/lib/js/dartium/js_dartium.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Support for interoperating with JavaScript.
  * 
  * This library provides access to JavaScript objects from Dart, allowing
  * Dart code to get and set properties, and call methods of JavaScript objects
  * and invoke JavaScript functions. The library takes care of converting
@@ skipping 65 matching lines @@
  * `a` and `b` defined:
  *
  *     var jsMap = new JsObject.jsify({'a': 1, 'b': 2});
  * 
  * This expression creates a JavaScript array:
  *
  *     var jsArray = new JsObject.jsify([1, 2, 3]);
  */
 library dart.js;
 
+import 'dart:collection' show ListMixin;
 import 'dart:nativewrappers';
 
 JsObject _cachedContext;
 
 JsObject get _context native "Js_context_Callback";
 
 JsObject get context {
   if (_cachedContext == null) {
     _cachedContext = _context;
   }
@@ skipping 157 matching lines @@
    * rather than opaque handles. This method is private because it cannot be
    * efficiently implemented in Dart2Js so should only be used by internal
    * tools.
    */
   _applyDebuggerOnly(List args, {thisArg}) native "JsFunction_applyDebuggerOnly";
 
   static JsFunction _withThis(Function f) native "JsFunction_withThis";
 }
 
 /**
+ * A [List] proxying a JavaScript Array.
+ */
+class JsArray<E> extends JsObject with ListMixin<E> {
+
+  factory JsArray() => _newJsArray();
+
+  static JsArray _newJsArray() native "JsArray_newJsArray";
+
+  factory JsArray.from(Iterable<E> other) => _newJsArrayFromSafeList(new List.from(other));
+
+  static JsArray _newJsArrayFromSafeList(List list) native "JsArray_newJsArrayFromSafeList";
+
+  _checkIndex(int index, {bool insert: false}) {
+    int length = insert ? this.length + 1 : this.length;
+    if (index is int && (index < 0 || index >= length)) {
+      throw new RangeError.range(index, 0, length);
+    }
+  }
+
+  _checkRange(int start, int end) {
+    int cachedLength = this.length;
+    if (start < 0 || start > cachedLength) {
+      throw new RangeError.range(start, 0, cachedLength);
+    }
+    if (end < start || end > cachedLength) {
+      throw new RangeError.range(end, start, cachedLength);
+    }
+  }
+
+  // Methods required by ListMixin
+
+  E operator [](int index) {
+    _checkIndex(index);
+    return super[index];
+  }
+
+  void operator []=(int index, E value) {
+    _checkIndex(index);
+    super[index] = value;
+  }
+
+  int get length native "JsArray_length";
+
+  void set length(int length) { super['length'] = length; }
+
+  // Methods overriden for better performance
+
+  void add(E value) {
+    callMethod('push', [value]);
+  }
+
+  void addAll(Iterable<E> iterable) {
+    // TODO(jacobr): this can be optimized slightly.
+    callMethod('push', new List.from(iterable));
+  }
+
+  void insert(int index, E element) {
+    _checkIndex(index, insert:true);
+    callMethod('splice', [index, 0, element]);
+  }
+
+  E removeAt(int index) {
+    _checkIndex(index);
+    return callMethod('splice', [index, 1])[0];
+  }
+
+  E removeLast() {
+    if (length == 0) throw new RangeError(-1);
+    return callMethod('pop');
+  }
+
+  void removeRange(int start, int end) {
+    _checkRange(start, end);
+    callMethod('splice', [start, end - start]);
+  }
+
+  void setRange(int start, int end, Iterable<E> iterable, [int skipCount = 0]) {
+    _checkRange(start, end);
+    int length = end - start;
+    if (length == 0) return;
+    if (skipCount < 0) throw new ArgumentError(skipCount);
+    var args = [start, length]..addAll(iterable.skip(skipCount).take(length));
+    callMethod('splice', args);
+  }
+
+  void sort([int compare(E a, E b)]) {
+    callMethod('sort', [compare]);
+  }
+}
+
+/**
  * Placeholder object for cases where we need to determine exactly how many
  * args were passed to a function.
  */
 const _UNDEFINED = const Object();
 
 // FIXME(jacobr): this method is a hack to work around the lack of proper dart
 // support for varargs methods.
 List _stripUndefinedArgs(List args) =>
     args.takeWhile((i) => i != _UNDEFINED).toList();
 
 /**
  * Returns a method that can be called with an arbitrary number (for n less
  * than 11) of arguments without violating Dart type checks.
  */
 Function _wrapAsDebuggerVarArgsFunction(JsFunction jsFunction) =>
   ([a1=_UNDEFINED, a2=_UNDEFINED, a3=_UNDEFINED, a4=_UNDEFINED,
     a5=_UNDEFINED, a6=_UNDEFINED, a7=_UNDEFINED, a8=_UNDEFINED,
     a9=_UNDEFINED, a10=_UNDEFINED]) =>
     jsFunction._applyDebuggerOnly(_stripUndefinedArgs(
         [a1,a2,a3,a4,a5,a6,a7,a8,a9,a10]));