Add JsArray

sdk/lib/js/dart2js/js_dart2js.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.
 
 library dart.js;
 
 import 'dart:html' show Blob, ImageData, Node;
-import 'dart:collection' show HashMap;
+import 'dart:collection' show HashMap, ListMixin;
 import 'dart:indexed_db' show KeyRange;
 import 'dart:typed_data' show TypedData;
 
 import 'dart:_foreign_helper' show JS, DART_CLOSURE_TO_JS;
 import 'dart:_interceptors' show JavaScriptObject, UnknownJavaScriptObject;
 import 'dart:_js_helper' show Primitives, convertDartClosureToJS;
 
 final JsObject context = new JsObject._fromJs(Primitives.computeGlobalThis());
 
 _convertDartFunction(Function f, {bool captureThis: false}) {
   return JS('',
     'function(_call, f, captureThis) {'
       'return function() {'
         'return _call(f, captureThis, this, '
             'Array.prototype.slice.apply(arguments));'
       '}'
     '}(#, #, #)', DART_CLOSURE_TO_JS(_callDartFunction), f, captureThis);
 }
 
 _callDartFunction(callback, bool captureThis, self, List arguments) {
   if (captureThis) {
     arguments = [self]..addAll(arguments);
   }
-  var dartArgs = arguments.map(_convertToDart).toList();
+  var dartArgs = new List.from(arguments.map(_convertToDart));
   return _convertToJS(Function.apply(callback, dartArgs));
 }
 
 
 class JsObject {
   // The wrapped JS object.
   final dynamic _jsObject;
 
   JsObject._fromJs(this._jsObject) {
     assert(_jsObject != null);
@@ skipping 137 matching lines @@
       return super.toString();
     }
   }
 
   dynamic callMethod(name, [List args]) {
     if (name is! String && name is! num) {
       throw new ArgumentError("name is not a String or num");
     }
     return _convertToDart(JS('', '#[#].apply(#, #)', _jsObject, name,
         _jsObject,
-        args == null ? null : args.map(_convertToJS).toList()));
+        args == null ? null : new List.from(args.map(_convertToJS))));
   }
 }
 
 class JsFunction extends JsObject {
 
   /**
    * Returns a [JsFunction] that captures its 'this' binding and calls [f]
    * with the value of this passed as the first argument.
    */
   factory JsFunction.withThis(Function f) {
     var jsFunc = _convertDartFunction(f, captureThis: true);
     return new JsFunction._fromJs(jsFunc);
   }
 
   JsFunction._fromJs(jsObject) : super._fromJs(jsObject);
 
   dynamic apply(List args, { thisArg }) =>
       _convertToDart(JS('', '#.apply(#, #)', _jsObject,
           _convertToJS(thisArg),
-          args == null ? null : args.map(_convertToJS).toList()));
+          args == null ? null : new List.from(args.map(_convertToJS))));
+}
+
+/**
+ * A [List] that is stored in a JavaScript array.
+ */
+class JsArray<E> extends JsObject with ListMixin<E> {
+
+  JsArray() : super._fromJs([]);
+
+  JsArray.from(Iterable<E> other)
+      : super._fromJs([]..addAll(other.map(_convertToJS)));
+
+  JsArray._fromJs(jsObject) : super._fromJs(jsObject);
+
+  _checkIndex(int index, {bool insert: false}) {

[Jacob, 2013/10/24 21:02:09]

why not have two check index methods? one for insert and one for the regular
case?

[justinfagnani, 2013/10/26 03:26:52]

Done.

+    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) {
+    if (start < 0 || start > this.length) {
+      throw new RangeError.range(start, 0, this.length);
+    }
+    if (end < start || end > this.length) {
+      throw new RangeError.range(end, start, this.length);
+    }
+  }
+
+  // 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 => super['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) {
+    var list = (JS('bool', '# instanceof Array', iterable)) 
+        ? iterable
+        : new List.from(iterable);
+    callMethod('push', list);
+  }
+
+  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]);
+  }
 }
 
 // property added to a Dart object referencing its JS-side DartObject proxy
 const _DART_OBJECT_PROPERTY_NAME = r'_$dart_dartObject';
 const _DART_CLOSURE_PROPERTY_NAME = r'_$dart_dartClosure';
 
 // property added to a JS object referencing its Dart-side JsObject proxy
 const _JS_OBJECT_PROPERTY_NAME = r'_$dart_jsObject';
 const _JS_FUNCTION_PROPERTY_NAME = r'$dart_jsFunction';
 
@@ skipping 53 matching lines @@
     return o;
   } else if (o is Blob || o is KeyRange || o is ImageData || o is Node
     || o is TypedData) {
     return JS('Blob|KeyRange|ImageData|Node|TypedData', '#', o);
   } else if (JS('bool', '# instanceof Date', o)) {
     var ms = JS('num', '#.getMilliseconds()', o);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   } else if (JS('bool', 'typeof # == "function"', o)) {
     return _getDartProxy(o, _DART_CLOSURE_PROPERTY_NAME,
         (o) => new JsFunction._fromJs(o));
+  } else if (JS('bool', '# instanceof Array', o)) {
+    return _getDartProxy(o, _DART_OBJECT_PROPERTY_NAME,
+        (o) => new JsArray._fromJs(o));
   } else if (JS('bool', '#.constructor === DartObject', o)) {
     return JS('', '#.o', o);
   } else {
     return _getDartProxy(o, _DART_OBJECT_PROPERTY_NAME,
         (o) => new JsObject._fromJs(o));
   }
 }
 
 Object _getDartProxy(o, String propertyName, createProxy(o)) {
   var dartProxy = JS('', '#[#]', o, propertyName);
   if (dartProxy == null) {
     dartProxy = createProxy(o);
     _defineProperty(o, propertyName, dartProxy);
   }
   return dartProxy;
 }