Support user generated custom native JS classes.

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.
 
 /**
  * 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 74 matching lines @@
  *
  *     var jsArray = new JsObject.jsify([1, 2, 3]);
  */
 library dart.js;
 
 import 'dart:html' show Blob, Event, ImageData, Node, Window;
 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,
-    getIsolateAffinityTag;
+import 'dart:_foreign_helper' show JS, JS_CONST, DART_CLOSURE_TO_JS;
+import 'dart:_interceptors'
+    show JavaScriptObject, UnknownJavaScriptObject, DART_CLOSURE_PROPERTY_NAME;
+import 'dart:_js_helper'
+    show Primitives, convertDartClosureToJS, getIsolateAffinityTag;
+
+export 'dart:_interceptors' show Interceptor, JavaScriptObject, JSArray;
 
 final JsObject context = _wrapToDart(JS('', 'self'));
 
 _convertDartFunction(Function f, {bool captureThis: false}) {
-  return JS('',
-    'function(_call, f, captureThis) {'
+  return JS(
+      '',
+      'function(_call, f, captureThis) {'

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

+1 on using ''' to restore indentation

[Jacob, 2015/10/01 00:47:33]

this file is now automatically formatted so please send your whitespace style
complaints to Bob :)

[sra1, 2015/10/01 17:34:30]

When this was originally written JS didn't parse functions so the indented
strings reduced space in the output.

Now we parse the whole thing, so use whitespace liberally to make it look nice.

[Siggi Cherem (dart-lang), 2015/10/01 18:21:28]

to clarify, what I meant was to use the triple-' going forward, which dartfmt
leaves alone :)

[Jacob, 2015/10/02 20:08:15]

fine. I switched to ''' and did a bunch of white space deck chair moving.

       'return function() {'
-        'return _call(f, captureThis, this, '
-            'Array.prototype.slice.apply(arguments));'
+      'return _call(f, captureThis, this, '
+      'Array.prototype.slice.apply(arguments));'
       '}'
-    '}(#, #, #)', DART_CLOSURE_TO_JS(_callDartFunction), f, captureThis);
+      '}(#, #, #)',
+      DART_CLOSURE_TO_JS(_callDartFunction),
+      f,
+      captureThis);
 }
 
 _callDartFunction(callback, bool captureThis, self, List arguments) {
   if (captureThis) {
     arguments = [self]..addAll(arguments);
   }
   var dartArgs = new List.from(arguments.map(_convertToDart));
   return _convertToJS(Function.apply(callback, dartArgs));
 }
 
@@ skipping 85 matching lines @@
    *
    * Use this constructor only if you wish to get access to JavaScript
    * properties attached to a browser host object, such as a Node or Blob, that
    * is normally automatically converted into a native Dart object.
    *
    * An exception will be thrown if [object] either is `null` or has the type
    * `bool`, `num`, or `String`.
    */
   factory JsObject.fromBrowserObject(object) {
     if (object is num || object is String || object is bool || object == null) {
-      throw new ArgumentError(
-        "object cannot be a num, string, bool, or null");
+      throw new ArgumentError("object cannot be a num, string, bool, or null");
     }
     return _wrapToDart(_convertToJS(object));
   }
 
   /**
    * Recursively converts a JSON-like collection of Dart objects to a
    * collection of JavaScript objects and returns a [JsObject] proxy to it.
    *
    * [object] must be a [Map] or [Iterable], the contents of which are also
    * converted. Maps and Iterables are copied to a new JavaScript object.
@@ skipping 33 matching lines @@
 
     return _convert(data);
   }
 
   /**
    * Returns the value associated with [property] from the proxied JavaScript
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
-  dynamic operator[](property) {
+  dynamic operator [](property) {
     if (property is! String && property is! num) {
       throw new ArgumentError("property is not a String or num");
     }
     return _convertToDart(JS('', '#[#]', _jsObject, property));
   }
 
   /**
    * Sets the value associated with [property] on the proxied JavaScript
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
-  operator[]=(property, value) {
+  operator []=(property, value) {
     if (property is! String && property is! num) {
       throw new ArgumentError("property is not a String or num");
     }
     JS('', '#[#]=#', _jsObject, property, _convertToJS(value));
   }
 
   int get hashCode => 0;
 
-  bool operator==(other) => other is JsObject &&
-      JS('bool', '# === #', _jsObject, other._jsObject);
+  bool operator ==(other) =>
+      other is JsObject && JS('bool', '# === #', _jsObject, other._jsObject);
 
   /**
    * Returns `true` if the JavaScript object contains the specified property
    * either directly or though its prototype chain.
    *
    * This is the equivalent of the `in` operator in JavaScript.
    */
   bool hasProperty(property) {
     if (property is! String && property is! num) {
       throw new ArgumentError("property is not a String or num");
@@ skipping 21 matching lines @@
   bool instanceof(JsFunction type) {
     return JS('bool', '# instanceof #', _jsObject, _convertToJS(type));
   }
 
   /**
    * Returns the result of the JavaScript objects `toString` method.
    */
   String toString() {
     try {
       return JS('String', 'String(#)', _jsObject);
-    } catch(e) {
+    } catch (e) {
       return super.toString();
     }
   }
 
   /**
    * Calls [method] on the JavaScript object with the arguments [args] and
    * returns the result.
    *
    * The type of [method] must be either [String] or [num].
    */
   dynamic callMethod(method, [List args]) {
     if (method is! String && method is! num) {
       throw new ArgumentError("method is not a String or num");
     }
-    return _convertToDart(JS('', '#[#].apply(#, #)', _jsObject, method,
+    return _convertToDart(JS(
+        '',
+        '#[#].apply(#, #)',
+        _jsObject,
+        method,
         _jsObject,
         args == null ? null : new List.from(args.map(_convertToJS))));
   }
 }
 
 /**
  * Proxies a JavaScript Function object.
  */
 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);
 
   /**
    * Invokes the JavaScript function with arguments [args]. If [thisArg] is
    * supplied it is the value of `this` for the invocation.
    */
-  dynamic apply(List args, { thisArg }) =>
-      _convertToDart(JS('', '#.apply(#, #)', _jsObject,
-          _convertToJS(thisArg),
-          args == null ? null : new List.from(args.map(_convertToJS))));
+  dynamic apply(List args, {thisArg}) => _convertToDart(JS(
+      '',
+      '#.apply(#, #)',
+      _jsObject,
+      _convertToJS(thisArg),
+      args == null ? null : new List.from(args.map(_convertToJS))));
 }
 
 /**
  * A [List] that proxies a JavaScript array.
  */
 class JsArray<E> extends JsObject with ListMixin<E> {
-
   /**
    * Creates a new JavaScript array.
    */
   JsArray() : super._fromJs([]);
 
   /**
    * Creates a new JavaScript array and initializes it to the contents of
    * [other].
    */
   JsArray.from(Iterable<E> other)
@@ skipping 45 matching lines @@
   int get length {
     // Check the length honours the List contract.
     var len = JS('', '#.length', _jsObject);
     // JavaScript arrays have lengths which are unsigned 32-bit integers.
     if (JS('bool', 'typeof # === "number" && (# >>> 0) === #', len, len, len)) {
       return JS('int', '#', len);
     }
     throw new StateError('Bad JsArray length');
   }
 
-  void set length(int length) { super['length'] = 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
@@ skipping 32 matching lines @@
 
   void sort([int compare(E a, E b)]) {
     // Note: arr.sort(null) is a type error in FF
     callMethod('sort', compare == null ? [] : [compare]);
   }
 }
 
 // property added to a Dart object referencing its JS-side DartObject proxy
 final String _DART_OBJECT_PROPERTY_NAME =
     getIsolateAffinityTag(r'_$dart_dartObject');
-final String _DART_CLOSURE_PROPERTY_NAME =
-    getIsolateAffinityTag(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';
+const _JS_FUNCTION_PROPERTY_NAME_CAPTURE_THIS = r'_$dart_jsFunctionCaptureThis';
 
 bool _defineProperty(o, String name, value) {
   if (_isExtensible(o) &&
       // TODO(ahe): Calling _hasOwnProperty to work around
       // https://code.google.com/p/dart/issues/detail?id=21331.
       !_hasOwnProperty(o, name)) {
     try {
       JS('void', 'Object.defineProperty(#, #, { value: #})', o, name, value);
       return true;
     } catch (e) {
@@ skipping 25 matching lines @@
 dynamic _convertToJS(dynamic o) {
   // Note: we don't write `if (o == null) return null;` to make sure dart2js
   // doesn't convert `return null;` into `return;` (which would make `null` be
   // `undefined` in Javascprit). See dartbug.com/20305 for details.
   if (o == null || o is String || o is num || o is bool) {
     return o;
   }
   if (o is JsObject) {
     return o._jsObject;
   }
-  if (o is Blob || o is Event || o is KeyRange || o is ImageData || o is Node ||
-      o is TypedData || o is Window) {
+  if (o is Blob ||
+      o is Event ||
+      o is KeyRange ||
+      o is ImageData ||
+      o is Node ||
+      o is TypedData ||
+      o is Window) {
     return o;
   }
   if (o is DateTime) {
     return Primitives.lazyAsJsDate(o);
   }
   if (o is Function) {
     return _getJsProxy(o, _JS_FUNCTION_PROPERTY_NAME, (o) {
       var jsFunction = _convertDartFunction(o);
       // set a property on the JS closure referencing the Dart closure
-      _defineProperty(jsFunction, _DART_CLOSURE_PROPERTY_NAME, o);
+      _defineProperty(jsFunction, DART_CLOSURE_PROPERTY_NAME, o);
       return jsFunction;
     });
   }
   var ctor = _dartProxyCtor;
-  return _getJsProxy(o, _JS_OBJECT_PROPERTY_NAME,
-      (o) => JS('', 'new #(#)', ctor, o));
+  return _getJsProxy(
+      o, _JS_OBJECT_PROPERTY_NAME, (o) => JS('', 'new #(#)', ctor, o));
 }
 
 Object _getJsProxy(o, String propertyName, createProxy(o)) {
   var jsProxy = _getOwnProperty(o, propertyName);
   if (jsProxy == null) {
     jsProxy = createProxy(o);
     _defineProperty(o, propertyName, jsProxy);
   }
   return jsProxy;
 }
 
 // converts a Dart object to a reference to a native JS object
 // which might be a DartObject JS->Dart proxy
 Object _convertToDart(o) {
   if (JS('bool', '# == null', o) ||
       JS('bool', 'typeof # == "string"', o) ||
       JS('bool', 'typeof # == "number"', o) ||
       JS('bool', 'typeof # == "boolean"', o)) {
     return o;
-  } else if (_isLocalObject(o)
-      && (o is Blob || o is Event || o is KeyRange || o is ImageData
-      || o is Node || o is TypedData || o is Window)) {
+  } else if (_isLocalObject(o) &&
+      (o is Blob ||
+          o is Event ||
+          o is KeyRange ||
+          o is ImageData ||
+          o is Node ||
+          o is TypedData ||
+          o is Window)) {
     // long line: dart2js doesn't allow string concatenation in the JS() form
     return JS('Blob|Event|KeyRange|ImageData|Node|TypedData|Window', '#', o);
   } else if (JS('bool', '# instanceof Date', o)) {
     var ms = JS('num', '#.getTime()', o);
     return new DateTime.fromMillisecondsSinceEpoch(ms);
   } else if (JS('bool', '#.constructor === #', o, _dartProxyCtor)) {
     return JS('', '#.o', o);
   } else {
     return _wrapToDart(o);
   }
 }
 
 JsObject _wrapToDart(o) {
   if (JS('bool', 'typeof # == "function"', o)) {
-    return _getDartProxy(o, _DART_CLOSURE_PROPERTY_NAME,
-        (o) => new JsFunction._fromJs(o));
+    return _getDartProxy(
+        o, DART_CLOSURE_PROPERTY_NAME, (o) => new JsFunction._fromJs(o));
   }
   if (JS('bool', '# instanceof Array', o)) {
-    return _getDartProxy(o, _DART_OBJECT_PROPERTY_NAME,
-        (o) => new JsArray._fromJs(o));
+    return _getDartProxy(
+        o, _DART_OBJECT_PROPERTY_NAME, (o) => new JsArray._fromJs(o));
   }
-  return _getDartProxy(o, _DART_OBJECT_PROPERTY_NAME,
-      (o) => new JsObject._fromJs(o));
+  return _getDartProxy(
+      o, _DART_OBJECT_PROPERTY_NAME, (o) => new JsObject._fromJs(o));
 }
 
 Object _getDartProxy(o, String propertyName, createProxy(o)) {
   var dartProxy = _getOwnProperty(o, propertyName);
   // Temporary fix for dartbug.com/15193
   // In some cases it's possible to see a JavaScript object that
   // came from a different context and was previously proxied to
   // Dart in that context. The JS object will have a cached proxy
   // but it won't be a valid Dart object in this context.
   // For now we throw away the cached proxy, but we should be able
   // to cache proxies from multiple JS contexts and Dart isolates.
   if (dartProxy == null || !_isLocalObject(o)) {
     dartProxy = createProxy(o);
     _defineProperty(o, propertyName, dartProxy);
   }
   return dartProxy;
 }
+
+// Start of methods for new style Dart-JS interop.
+
+class _JavaScriptFunctionHack implements Function {
+  call(
+      [a = const JS_CONST('void 0'),
+      b = const JS_CONST('void 0'),
+      c = const JS_CONST('void 0'),
+      d = const JS_CONST('void 0'),
+      e = const JS_CONST('void 0'),
+      f = const JS_CONST('void 0'),
+      g = const JS_CONST('void 0'),
+      h = const JS_CONST('void 0'),
+      i = const JS_CONST('void 0'),
+      j = const JS_CONST('void 0')]) {
+    // Exceedingly slow default implementation.
+    return JS('', '#.apply(null, #)', this,
+        _stripUndefinedArgs([a, b, c, d, e, f, g, h, i, j]));
+  }
+}
+
+void _copyOwnProperties(src, dest) {
+  JS(
+      '',
+      r"""(function(src, dest) {
+  var properties = Object.getOwnPropertyNames(src);
+  for (var i = 0, len = properties.length; i < len; i++) {
+    var name = properties[i];
+    dest[name] = src[name];
+  }
+})(#, #)""",
+      src,
+      dest);
+}
+
+// TODO(jacobr): remove this method. So far it appears that specifying the list
+// of registered types in Dart2Js has significant negative code size
+// implications so it is better to specify usage purely based on which
+// libraries are imported. Remove after Dartium is modified to function without

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

would it make sense to use tree-shakeable lookup-maps to describe dependencies
between jsinterop types instead?

[Jacob, 2015/10/02 20:08:15]

could be. moved away from requiring this method instead.

+// requiring this method.
+void registerJsInterfaces([List<Type> types]) {

[Siggi Cherem (dart-lang), 2015/09/18 20:34:10]

I seem to be missing something, is `types` used anywhere? Only in the dartium
implementation?

You could also change this implementation to make it easier for dart2js to
inline it and decide that `types` is not used. For example, just doing a
forwarding call like this:

  registerJsInterfaces([types]) => _registerFunctionHacks();
  _registerFunctionHacks() {
   ...
  }

might be enough.

[Jacob, 2015/10/01 00:47:33]

This was used in Dartium. I've ripped it out there and just traversed all
libraries using mirrors. I think this method should get removed completely and
this code should be emitted directly in codegen if the new JS interop is used at
all. Sound reasonable?
On 2015/09/18 20:34:10, Siggi Cherem (dart-lang) wrote:

+  // No need to actually register in Dart2JS.
+  var fnHackProto = JS('', '#.__proto__', new _JavaScriptFunctionHack());
+  var fnProto = JS('', 'Function.prototype');
+  _copyOwnProperties(fnHackProto, fnProto);
+  // Add optimized call methods for small numbers of arguments.
+  if (JS('bool', r'#.hasOwnProperty("call$0") ', fnHackProto)) {
+    JS('', r'#.call$0 = function() { return this(); }', fnProto);
+    JS('', r'#.call$1 = function(a) { return this(a); }', fnProto);
+    JS('', r'#.call$2 = function(a, b) { return this(a, b); }', fnProto);
+    JS('', r'#.call$3 = function(a, b, c) { return this(a, b, c); }', fnProto);
+    JS('', r'#.call$4 = function(a, b, c, d) { return this(a, b, c, d); }',
+        fnProto);
+  } else {
+    if (!JS('bool', r'#.hasOwnProperty("$0") ', fnHackProto)) {
+      throw 'Internal error. Unexpected minified output';
+    }
+    JS('', r'#.$0 = function() { return this(); }', fnProto);
+    JS('', r'#.$1 = function(a) { return this(a); }', fnProto);
+    JS('', r'#.$2 = function(a, b) { return this(a, b); }', fnProto);
+    JS('', r'#.$3 = function(a, b, c) { return this(a, b, c); }', fnProto);
+    JS('', r'#.$4 = function(a, b, c, d) { return this(a, b, c, d); }',
+        fnProto);
+  }
+}
+
+_convertDartFunctionFast(Function f, {bool captureThis: false}) {
+  var existing = JS('', '#.#', f, _JS_FUNCTION_PROPERTY_NAME);
+  if (existing != null) return existing;
+  var ret = JS(
+      '',
+      'function(_call, f) {'
+      'return function() {'
+      'return _call(f, Array.prototype.slice.apply(arguments));'
+      '}'
+      '}(#, #)',
+      DART_CLOSURE_TO_JS(_callDartFunctionFast),
+      f);
+  JS('', '#.# = #', ret, DART_CLOSURE_PROPERTY_NAME, f);
+  JS('', '#.# = #', f, _JS_FUNCTION_PROPERTY_NAME, ret);
+  return ret;
+}
+
+_convertDartFunctionFastCaptureThis(Function f) {
+  var existing =
+      JS('', '#.#', f, _JS_FUNCTION_PROPERTY_NAME_CAPTURE_THIS);
+  if (existing != null) return existing;
+  var ret = JS(
+      '',
+      'function(_call, f) {'
+      'return function() {'
+      'return _call(f, this, '
+      'Array.prototype.slice.apply(arguments));'
+      '}'
+      '}(#, #)',
+      DART_CLOSURE_TO_JS(_callDartFunctionFastCaptureThis),
+      f);
+  JS('', '#.# = #', ret, DART_CLOSURE_PROPERTY_NAME, f);
+  JS('', '#.# = #', f, _JS_FUNCTION_PROPERTY_NAME_CAPTURE_THIS, ret);
+  return ret;
+}
+
+_callDartFunctionFast(callback, List arguments) {
+  return Function.apply(callback, arguments);
+}
+
+_callDartFunctionFastCaptureThis(callback, self, List arguments) {
+  return _convertToJS(Function.apply(callback, [self]..addAll(arguments)));
+}
+
+Function allowInterop(Function f) {
+  if (JS('bool', 'typeof(#) == "function"', f)) {
+    // Already supports interop, just use the existing function.
+    return f;
+  } else {
+    return _convertDartFunctionFast(f);
+  }
+}
+
+Function allowInteropCaptureThis(Function f) {
+  if (JS('bool', 'typeof(#) == "function"', f)) {
+    // Behavior when the function is already a JS function is unspecified.
+    throw new ArgumentError(
+        "Function is already a JS function so cannot capture this.");
+    return f;
+  } else {
+    return _convertDartFunctionFastCaptureThis(f);
+  }
+}