add JsArray and JsObject.asJsMap()

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:collection' show ListMixin, Maps;
 import 'dart:_foreign_helper' show JS;
 import 'dart:_js_helper' show convertDartClosureToJS;
 
 JsObject get context {
   return new JsObject._fromJs(JS('=Object', 'window'));
 }
 
 JsObject jsify(dynamic data) => data == null ? null : new JsObject._json(data);
 
 class Callback implements Serializable<JsFunction> {
@@ skipping 77 matching lines @@
     return new JsObject._fromJs(JS('=Object', r'''(function(){
 var Type = function(){};
 Type.prototype = #.prototype;
 var instance = new Type();
 ret = #.apply(instance, #);
 ret = Object(ret) === ret ? ret : instance;
 return ret;
 })()''', constr, constr, args));
   }
 
-  factory JsObject._json(data) => new JsObject._fromJs(_convertDataTree(data));
+  factory JsObject._json(data) => _convertToDart(_convertDataTree(data));
 
   static _convertDataTree(data) {
     if (data is Map) {
       final convertedData = JS('=Object', '{}');
       for (var key in data.keys) {
         JS('=Object', '#[#]=#', convertedData, key,
             _convertDataTree(data[key]));
       }
       return convertedData;
     } else if (data is Iterable) {
@@ skipping 32 matching lines @@
       return JS('String', '#.toString()', _convertToJS(this));
     } catch(e) {
       return super.toString();
     }
   }
 
   callMethod(String name, [List args]) =>
       _convertToDart(JS('=Object', '#[#].apply(#, #)', _convertToJS(this), name,
           _convertToJS(this),
           args == null ? null : args.map(_convertToJS).toList()));
+
+  Map<String, dynamic> asJsMap() => new _JsObjectAsMap(this);
 }
 
 class JsFunction extends JsObject implements Serializable<JsFunction> {
   JsFunction._fromJs(jsObject) : super._fromJs(jsObject);
   apply(thisArg, [List args]) =>
       _convertToDart(JS('=Object', '#.apply(#, #)', _convertToJS(this),
           _convertToJS(thisArg),
           args == null ? null : args.map(_convertToJS).toList()));
 }
 
+/// A [JsObject] subtype for JavaScript arrays.
+class JsArray extends JsObject with ListMixin {
+  JsArray._fromJs(jsObject) : super._fromJs(jsObject);
+
+  // Iterable
+  /*@override*/ int get length => super['length'];
+
+  // Collection
+  /*@override*/ void add(value) { callMethod('push', [value]); }
+
+  // List
+  /*@override*/ operator [](index) {
+    if (index is int && (index < 0 || index >= this.length)) {

[vsm, 2013/08/20 15:44:13]

Should JsArray throw on non-int indices?

[alexandre.ardhuin, 2013/08/20 20:58:55]

In Js an array is an object. So it's possible to set a property even if it's not
a Number. I have kept this semantic.

I hesitate to get rid of this Range check because Js don't have it.

+      throw new RangeError.value(index);
+    }
+    return super[index];
+  }
+  /*@override*/ void operator []=(index, value) {
+    if (index is int && (index < 0 || index >= this.length)) {
+      throw new RangeError.value(index);
+    }
+    super[index] = value;
+  }
+  /*@override*/ void set length(int length) { super['length'] = length; }
+  /*@override*/ void sort([int compare(a, b)]) {
+    final sortedList = toList()..sort(compare);
+    setRange(0, sortedList.length, sortedList);
+  }
+  /*@override*/ void insert(int index, element) {
+    callMethod('splice', [index, 0, element]);
+  }
+  /*@override*/ removeAt(int index) {
+    if (index < 0 || index >= this.length) throw new RangeError.value(index);
+    return callMethod('splice', [index, 1])[0];
+  }
+  /*@override*/ removeLast() => callMethod('pop');
+  /*@override*/ void setRange(int start, int length, List from,
+                              [int startFrom = 0]) {
+    final args = [start, length];
+    for(int i = startFrom; i < startFrom + length; i++) {
+      args.add(from[i]);
+    }
+    callMethod('splice', args);
+  }
+  /*@override*/ void removeRange(int start, int end) {
+    callMethod('splice', [start, end - start]);
+  }
+}
+
+class _JsObjectAsMap implements Map<String, dynamic> {
+  JsObject _jsObject;

[vsm, 2013/08/20 15:44:13]

It seems odd that Array extends JsObject while Map wraps it.  What's the reason
for the difference?

[alexandre.ardhuin, 2013/08/20 20:58:55]

Ideally I would have made JsObject implementing Map<String, dynamic>. This is
not possible if JsArray (that implements List) extends JsObject because Map and
List have some incompatible functions (for instance list.forEach(void f(E
element)) vs. map.forEach(void f(K key, V value)))

Moreover in Js there is not really maps.

So I had decided to reflect the Js types by making JsArray extends JsObject (in
Js Array "extends" Object) and provide a way (with .asDartMap()) to handle
JsObject as a Map.

+
+  _JsObjectAsMap(this._jsObject);
+
+  /*@override*/ operator [](String key) => _jsObject[key];
+  /*@override*/ void operator []=(String key, value) {
+    _jsObject[key] = value;
+  }
+  /*@override*/ remove(String key) {
+    final value = this[key];
+    _jsObject.deleteProperty(key);
+    return value;
+  }
+  /*@override*/ Iterable<String> get keys =>
+      context['Object'].callMethod('keys', [_jsObject]);
+
+  // use Maps to implement functions
+  /*@override*/ bool containsValue(value) => Maps.containsValue(this, value);
+  /*@override*/ bool containsKey(String key) => Maps.containsKey(this, key);
+  /*@override*/ putIfAbsent(String key, ifAbsent()) =>
+      Maps.putIfAbsent(this, key, ifAbsent);
+  /*@override*/ void addAll(Map<String, dynamic> other) {
+    if (other != null) {
+      other.forEach((k,v) => this[k] = v);
+    }
+  }
+  /*@override*/ void clear() => Maps.clear(this);
+  /*@override*/ void forEach(void f(String key, value)) => Maps.forEach(this, f);
+  /*@override*/ Iterable get values => Maps.getValues(this);
+  /*@override*/ int get length => Maps.length(this);
+  /*@override*/ bool get isEmpty => Maps.isEmpty(this);
+  /*@override*/ bool get isNotEmpty => Maps.isNotEmpty(this);
+}
+
 abstract class Serializable<T> {
   T toJs();
 }
 
 dynamic _convertToJS(dynamic o) {
   if (o == null) {
     return null;
   } else if (o is String || o is num || o is bool) {
     return o;
   } else if (o is JsObject) {
     return o._jsObject;
   } else if (o is Serializable) {
     return _convertToJS(o.toJs());
   } else if (o is Function) {
     return _convertToJS(new Callback(o));
+  } else if (o is Map) {
+    return _convertToJS(jsify(o));
+  } else if (o is Iterable) {
+    return _convertToJS(jsify(o));
   } else {
     return JS('=Object', 'new DartProxy(#)', o);
   }
 }
 
 dynamic _convertToDart(dynamic o) {
   if (JS('bool', '# == null', o)) {
     return null;
   } else if (JS('bool', 'typeof # == "string" || # instanceof String', o, o) ||
       JS('bool', 'typeof # == "number" || # instanceof Number', o, o) ||
       JS('bool', 'typeof # == "boolean" || # instanceof Boolean', o, o)) {
     return o;
   } else if (JS('bool', '# instanceof Function', o)) {
     return new JsFunction._fromJs(JS('=Object', '#', o));
+  } else if (JS('bool', '# instanceof Array', o)) {
+    return new JsArray._fromJs(JS('=Object', '#', o));

[vsm, 2013/08/20 15:44:13]

After talking to sra, I think the right to put here (and 2 lines above) instead
of "=Object" is "var".  Though you may want to sanity check code size.

[alexandre.ardhuin, 2013/08/20 20:58:55]

Done

   } else if (JS('bool', '# instanceof DartProxy', o)) {
     return JS('var', '#.o', o);
   } else {
     return new JsObject._fromJs(JS('=Object', '#', o));
   }
 }