[js-interop] Fix function binding and avoid noSuchMethod when using map notation

lib/js.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.
 
 /**
  * The js.dart library provides simple JavaScript invocation from Dart that
  * works on both Dartium and on other modern browsers via Dart2JS.
  *
  * It provides a model based on scoped [Proxy] objects.  Proxies give Dart
  * code access to JavaScript objects, fields, and functions as well as the
@@ skipping 71 matching lines @@
 // one.
 
 // NOTE: Please re-run tools/create_bootstrap.dart on any modification of
 // this bootstrap string.
 final _JS_BOOTSTRAP = r"""
 (function() {
   // Proxy support for js.dart.
 
   var globalContext = window;
 
+  // Support for binding the receiver (this) in proxied functions.
+  function bindIfFunction(f, _this) {
+    if (typeof(f) != "function") {
+      return f;
+    } else {
+      return new BoundFunction(_this, f);
+    }
+  }
+
+  function unbind(obj) {
+    if (obj instanceof BoundFunction) {
+      return obj.object;
+    } else {
+      return obj;
+    }
+  }
+
+  function getBoundThis(obj) {
+    if (obj instanceof BoundFunction) {
+      return obj._this;
+    } else {
+      return globalContext;
+    }
+  }
+
+  function BoundFunction(_this, object) {
+    this._this = _this;
+    this.object = object;
+  }
+
   // Table for local objects and functions that are proxied.
   function ProxiedObjectTable() {
     // Name for debugging.
     this.name = 'js-ref';
 
     // Table from IDs to JS objects.
     this.map = {};
 
     // Generator for new IDs.
     this._nextId = 0;
@@ skipping 95 matching lines @@
   }
 
   ProxiedObjectTable.prototype._initialize = function () {
     // Configure this table's port to forward methods, getters, and setters
     // from the remote proxy to the local object.
     var table = this;
 
     this.port.receive(function (message) {
       // TODO(vsm): Support a mechanism to register a handler here.
       try {
-        var receiver = table.get(message[0]);
+        var object = table.get(message[0]);
+        var receiver = unbind(object);
         var member = message[1];
         var kind = message[2];
         var args = message[3].map(deserialize);
         if (kind == 'get') {
           // Getter.
           var field = member;
           if (field in receiver && args.length == 0) {
-            return [ 'return', serialize(receiver[field]) ];
+            var result = bindIfFunction(receiver[field], receiver);
+            return [ 'return', serialize(result) ];
           }
         } else if (kind == 'set') {
           // Setter.
           var field = member;
           if (args.length == 1) {
             return [ 'return', serialize(receiver[field] = args[0]) ];
           }
         } else if (kind == 'apply') {
           // Direct function invocation.
-          // TODO(vsm): Should we capture _this_ automatically?
-          return [ 'return', serialize(receiver.apply(null, args)) ];
+          var _this = getBoundThis(object);
+          return [ 'return', serialize(receiver.apply(_this, args)) ];
         } else if (member == '[]' && args.length == 1) {
           // Index getter.
-          return [ 'return', serialize(receiver[args[0]]) ];
+          var result = bindIfFunction(receiver[args[0]], receiver);
+          return [ 'return', serialize(result) ];
         } else if (member == '[]=' && args.length == 2) {
           // Index setter.
           return [ 'return', serialize(receiver[args[0]] = args[1]) ];
         } else {
+          // Member function invocation.
           var f = receiver[member];
           if (f) {
             var result = f.apply(receiver, args);
             return [ 'return', serialize(result) ];
           }
         }
         return [ 'none' ];
       } catch (e) {
         return [ 'throws', e.toString() ];
       }
@@ skipping 102 matching lines @@
                typeof(message) == 'number' ||
                typeof(message) == 'boolean') {
       // Primitives are passed directly through.
       return message;
     } else if (message instanceof SendPortSync) {
       // Non-proxied objects are serialized.
       return message;
     } else if (message instanceof Element &&
         (message.ownerDocument == null || message.ownerDocument == document)) {
       return [ 'domref', serializeElement(message) ];
+    } else if (message instanceof BoundFunction &&
+               typeof(message.object) == 'function') {

[alexandre.ardhuin, 2013/04/07 21:20:20]

Could typeof(message.object) be something else that function ?

[vsm, 2013/04/07 21:37:36]

It shouldn't.  I'll change this to assert that.

On 2013/04/07 21:20:20, alexandre.ardhuin wrote:

+      // Local function proxy.
+      return [ 'funcref',
+               proxiedObjectTable.add(message),
+               proxiedObjectTable.sendPort ];
     } else if (typeof(message) == 'function') {
       if ('_dart_id' in message) {
         // Remote function proxy.
         var remoteId = message._dart_id;
         var remoteSendPort = message._dart_port;
         return [ 'funcref', remoteId, remoteSendPort ];
       } else {
         // Local function proxy.
         return [ 'funcref',
                  proxiedObjectTable.add(message),
@@ skipping 70 matching lines @@
     } else {
       // Remote object.
       return new DartProxy(id, port);
     }
   }
 
   // Remote handler to construct a new JavaScript object given its
   // serialized constructor and arguments.
   function construct(args) {
     args = args.map(deserialize);
-    var constructor = args[0];
+    var constructor = unbind(args[0]);
     args = Array.prototype.slice.call(args, 1);
 
     // Until 10 args, the 'new' operator is used. With more arguments we use a
     // generic way that may not work, particulary when the constructor does not
     // have an "apply" method.
     var ret = null;
     if (args.length === 0) {
       ret = new constructor();
     } else if (args.length === 1) {
       ret = new constructor(args[0]);
@@ skipping 48 matching lines @@
            ' (out of ' + total + ' ever allocated).';
   }
 
   // Return true if two JavaScript proxies are equal (==).
   function proxyEquals(args) {
     return deserialize(args[0]) == deserialize(args[1]);
   }
 
   // Return true if a JavaScript proxy is instance of a given type (instanceof).
   function proxyInstanceof(args) {
-    return deserialize(args[0]) instanceof deserialize(args[1]);
+    var obj = unbind(deserialize(args[0]));
+    var type = unbind(deserialize(args[1]));
+    return obj instanceof type;
   }
 
   // Return true if a JavaScript proxy is instance of a given type (instanceof).
   function proxyDeleteProperty(args) {
-    delete deserialize(args[0])[deserialize(args[1])];
+    var obj = unbind(deserialize(args[0]));
+    var member = unbind(deserialize(args[1]));
+    delete obj[member];
   }
 
   function proxyConvert(args) {
     return serialize(deserializeDataTree(args));
   }
 
   function deserializeDataTree(data) {
     var type = data[0];
     var value = data[1];
     if (type === 'map') {
@@ skipping 287 matching lines @@
   /**
    * Creates a multi-fire [Callback] that invokes [f].  The callback must be
    * explicitly disposed to avoid memory leaks.
    */
   Callback.many(Function f) {
     _callback = (args) => Function.apply(f, args);
     _initialize(true);
   }
 }
 
+// Detect unspecified arguments.
+class _Undefined {
+  const _Undefined();
+}
+const _undefined = const _Undefined();
+List _pruneUndefined(arg1, arg2, arg3, arg4, arg5, arg6) {
+  // This assumes no argument
+  final args = [arg1, arg2, arg3, arg4, arg5, arg6];
+  final index = args.indexOf(_undefined);
+  if (index < 0) return args;
+  return args.sublist(0, index);
+}
+
 /**
  * Proxies to JavaScript objects.
  */
 class Proxy implements Serializable<Proxy> {
   SendPortSync _port;
   final _id;
 
   /**
    * Constructs a [Proxy] to a new JavaScript object by invoking a (proxy to a)
    * JavaScript [constructor].  The arguments should be either
    * primitive values, DOM elements, or Proxies.
    */
-  factory Proxy(FunctionProxy constructor, [arg1, arg2, arg3, arg4]) {
-      var arguments;
-      if (?arg4) {
-        arguments = [arg1, arg2, arg3, arg4];
-      } else if (?arg3) {
-        arguments = [arg1, arg2, arg3];
-      } else if (?arg2) {
-        arguments = [arg1, arg2];
-      } else if (?arg1) {
-        arguments = [arg1];
-      } else {
-        arguments = [];
-      }
+  factory Proxy(FunctionProxy constructor,
+      [arg1 = _undefined,
+       arg2 = _undefined,
+       arg3 = _undefined,
+       arg4 = _undefined,
+       arg5 = _undefined,
+       arg6 = _undefined]) {
+      var arguments = _pruneUndefined(arg1, arg2, arg3, arg4, arg5, arg6);
       return new Proxy.withArgList(constructor, arguments);
   }
 
   /**
    * Constructs a [Proxy] to a new JavaScript object by invoking a (proxy to a)
    * JavaScript [constructor].  The [arguments] list should contain either
    * primitive values, DOM elements, or Proxies.
    */
   factory Proxy.withArgList(FunctionProxy constructor, List arguments) {
     if (_depth == 0) throw 'Cannot create Proxy out of scope.';
@@ skipping 27 matching lines @@
       return ['list', data.map((e) => _serializeDataTree(e)).toList()];
     } else {
       return ['simple', _serialize(data)];
     }
   }
 
   Proxy._internal(this._port, this._id);
 
   Proxy toJs() => this;
 
-  // TODO(vsm): This is not required in Dartium, but
-  // it is in Dart2JS.
   // Resolve whether this is needed.
   operator[](arg) => _forward(this, '[]', 'method', [ arg ]);
 
-  // TODO(vsm): This is not required in Dartium, but
-  // it is in Dart2JS.
   // Resolve whether this is needed.
   operator[]=(key, value) => _forward(this, '[]=', 'method', [ key, value ]);
 
   // Test if this is equivalent to another Proxy.  This essentially
   // maps to JavaScript's == operator.
   // TODO(vsm): Can we avoid forwarding to JS?
-  operator==(Proxy other) => identical(this, other)
+  operator==(other) => identical(this, other)
       ? true
       : (other is Proxy &&
          _jsPortEquals.callSync([_serialize(this), _serialize(other)]));
 
   // Forward member accesses to the backing JavaScript object.
   noSuchMethod(InvocationMirror invocation) {
     String member = invocation.memberName;
     // If trying to access a JavaScript field/variable that starts with
     // _ (underscore), Dart treats it a library private and member name
     // it suffixed with '@internalLibraryIdentifier' which we have to
@@ skipping 19 matching lines @@
       }
       if (member.startsWith('set:')) {
         member = member.substring(4);
       }
     } else if (member.startsWith('get:')) {
       kind = 'get';
       member = member.substring(4);
     } else if (member.startsWith('set:')) {
       kind = 'set';
       member = member.substring(4);
+    } else if (member == 'call') {

[alexandre.ardhuin, 2013/04/07 21:20:20]

If what I have observed on minification of call is something that will not
change (ie. member looks like "call$1" "call$2"...), you can add the following
to the if.

member == 'call' || new RegExp(r"^call\$\d+$").hasMatch(member)

Thus even with minification of dart2js, the test "call JS function with
varargs." is passing.

[vsm, 2013/04/07 21:37:36]

I'm uncomfortable making an assumptions on minified names based on current
behavior.  I would expect it to change.  Let's see where bug 9283 ends up. 

On 2013/04/07 21:20:20, alexandre.ardhuin wrote:

+      // A 'call' (probably) means that this proxy was invoked directly
+      // as if it was a function.  Map this to JS function application.
+      kind = 'apply';
     } else {
       kind = 'method';
     }
     return _forward(this, member, kind, args);
   }
 
   // Forward member accesses to the backing JavaScript object.
   static _forward(Proxy receiver, String member, String kind, List args) {
     if (_depth == 0) throw 'Cannot access a JavaScript proxy out of scope.';
     var result = receiver._port.callSync([receiver._id, member, kind,
                                           args.map(_serialize).toList()]);
     switch (result[0]) {
       case 'return': return _deserialize(result[1]);
       case 'throws': throw _deserialize(result[1]);
       case 'none': throw new NoSuchMethodError(receiver, member, args, {});
       default: throw 'Invalid return value';
     }
   }
 }
 
 // TODO(aa) make FunctionProxy implements Function once it is allowed
 /// A [Proxy] subtype to JavaScript functions.
 class FunctionProxy extends Proxy /*implements Function*/ {
   FunctionProxy._internal(port, id) : super._internal(port, id);
 
-  noSuchMethod(InvocationMirror invocation) {
-    if (invocation.isMethod && invocation.memberName == 'call') {
-      var message = [_id, '', 'apply',
-                     invocation.positionalArguments.map(_serialize).toList()];
-      var result = _port.callSync(message);
-      if (result[0] == 'throws') throw result[1];
-      return _deserialize(result[1]);
-    } else {
-      return super.noSuchMethod(invocation);
-    }
+  // TODO(vsm): This allows calls with a limited number of arguments
+  // in the context of dartbug.com/9283.  Eliminate pending the resolution
+  // of this bug.  Note, if this Proxy is called with more arguments then
+  // allowed below, it will trigger the 'call' path in Proxy.noSuchMethod
+  // - and still work correctly in unminified mode.
+  call([arg1 = _undefined, arg2 = _undefined,
+        arg3 = _undefined, arg4 = _undefined,
+        arg5 = _undefined, arg6 = _undefined]) {
+    var arguments = _pruneUndefined(arg1, arg2, arg3, arg4, arg5, arg6);
+    return Proxy._forward(this, '', 'apply', arguments);
   }
 }
 
 /// Marker class used to indicate it is serializable to js. If a class is a
 /// [Serializable] the "toJs" method will be called and the result will be used
 /// as value.
 abstract class Serializable<T> {
   T toJs();
 }
 
@@ skipping 282 matching lines @@
  * Prints the number of live handles in Dart and JavaScript.  This is for
  * debugging / profiling purposes.
  */
 void proxyDebug([String message = '']) {
   print('Proxy status $message:');
   var live = _proxiedObjectTable.count;
   var total = _proxiedObjectTable.total;
   print('  Dart objects Live : $live (out of $total ever allocated).');
   print('  ${_jsPortDebug.callSync([])}');
 }