Write our JS blobs for handling native classes in Dart.

frog/leg/lib/native_helper.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.
+
+String chromeTypeNameOf(obj) {

[ahe, 2012/03/26 14:01:23]

Generally, I would prefer if these methods followed this naming convention:

descriptiveNameBrowserName

For example,

typeNameOfChrome

[ngeoffray, 2012/03/26 14:13:44]

Done.

+  String name = JS('String', "#.constructor.name", obj);
+  if (name == 'Window') return 'DOMWindow';
+  return name;
+}
+
+String firefoxTypeNameOf(obj) {
+  String name = constructorNameFallback(obj);
+  if (name == 'Window') return 'DOMWindow';
+  if (name == 'Document') return 'HTMLDocument';
+  if (name == 'XMLDocument') return 'Document';
+  return name;
+}
+
+String ieTypeNameOf(obj) {
+  String name = constructorNameFallback(obj);
+  if (name == 'Window') return 'DOMWindow';
+  // IE calls both HTML and XML documents 'Document', so we check for the
+  // xmlVersion property, which is the empty string on HTML documents.
+  if (name == 'Document' && JS('bool', '#.xmlVersion', obj)) return 'Document';

[ahe, 2012/03/26 14:01:23]

I doubt that this is really a bool: JS('bool', '#.xmlVersion', obj)

[ngeoffray, 2012/03/26 14:13:44]

Done.

+  if (name == 'Document') return 'HTMLDocument';
+  return name;
+}
+
+String constructorNameFallback(obj) {
+  var constructor = JS('var', "#.constructor", obj);
+  if (JS('bool', "typeof(#) == 'function'", constructor)) {

[ahe, 2012/03/26 14:01:23]

I think we have generally used this pattern, but isn't this better:

if ('function' === JS('String', 'typeof(#)', constructor)) {

We could even have:

String typeof(obj) => JS('String', 'typeof(#)', obj);

[ngeoffray, 2012/03/26 14:13:44]

Yeah, that could be better.
True, but code that does typeof in our core library is so performance critical,
that I'd rather wait that we can inline before using this helper.

[ahe, 2012/03/27 09:42:08]

I don't know if it is a problem to use === on strings. Florian has complained
about it before, and it is definitely very implementation dependent.

+    // The constructor isn't null or undefined at this point. Try
+    // to grab hold of its name.
+    var name = JS('var', '#.name', constructor);
+    // If the name is a non-empty string, we use that as the type
+    // name of this object. On Firefox, we often get 'Object' as
+    // the constructor name even for more specialized objects so
+    // we have to fall through to the toString() based implementation
+    // below in that case.
+    if (JS('bool', "typeof(#) == 'string'", name)
+        && JS('bool', '#', name)

[ahe, 2012/03/26 14:57:28]

This is not a boolean and I think it is unnecessary.

[ngeoffray, 2012/03/27 09:17:35]

It's necessary because it's checking if the string is empty. I have changed the
code to 'name.isEmpty()'.

+        && name != 'Object') {
+      return name;
+    }
+  }
+  String string = JS('String', 'Object.prototype.toString.call(#)', obj);
+  return string.substring(8, string.length - 1);

[ahe, 2012/03/26 14:57:28]

I'm concerned about this. We should share this with Primitives.objectToString. I
think the regular expression there is more correct.

[ngeoffray, 2012/03/27 09:17:35]

Probably, but I'd wait another CL to make sure it's correct on all browsers to
use Primitives.objectToString. Note that this only concerns DOM types.

+}
+
+
+/**
+ * Returns the function to use to get the type name of an object.
+ */
+Function getTypeNameOfFunction() {
+  // If we're not in the browser, we're almost certainly running on v8.
+  if (JS("bool", "typeof(navigator) != 'object'")) return chromeTypeNameOf;
+
+  String userAgent = JS('String', "navigator.userAgent");
+  if (userAgent.contains(const RegExp('Chrome|DumpRenderTree'))) {
+    return chromeTypeNameOf;
+  } else if (userAgent.contains('Firefox')) {
+    return firefoxTypeNameOf;
+  } else if (userAgent.contains('MSIE')) {
+    return ieTypeNameOf;
+  } else {
+    return constructorNameFallback;
+  }
+}
+
+
+/**
+ * Cached value for the function to use to get the type name of an
+ * object.
+ */
+Function _getTypeNameOf;
+
+/**
+ * Returns the type name of [obj].
+ */
+String getTypeNameOf(var obj) {
+  if (_getTypeNameOf == null) _getTypeNameOf = getTypeNameOfFunction();

[ahe, 2012/03/26 14:57:28]

===

[ngeoffray, 2012/03/27 09:17:35]

Done.

+  return _getTypeNameOf(obj);
+}
+
+/**
+ * Sets a JavaScript property on an object.
+ */
+void defineProperty(var obj, String property, var value) {
+  JS('void', """Object.defineProperty(#, #,
+      {value: #, enumerable: false, writable: false, configurable: true});""",
+      obj,
+      property,
+      value);
+}
+
+/**
+ * Helper method to throw a [NoSuchMethodException] for a invalid call
+ * on a native object.
+ */
+void throwNoSuchMethod(obj, name, arguments) {
+  throw new NoSuchMethodException(obj, name, arguments);
+}
+
+/**
+ * Returns a method that queries [methods] with the prototype of [obj],
+ * patches the prototype of [obj] with the found JS code,
+ * and invokes the JS code.

[ahe, 2012/03/26 14:57:28]

This comment is convoluted and it doesn't match what the method is doing.

The method *looks* *up* the type name of [obj] in [methods].

What is methods (I assume a JS object)?

[ngeoffray, 2012/03/27 09:17:35]

Comment updated. Yes [methods] is a JS object, see TODO in dynamicFunction,
where I say that we could try to make it a map.

+ */
+dynamicBind(var obj,
+            String name,

[ahe, 2012/03/26 14:57:28]

What is the name for?

[ngeoffray, 2012/03/27 09:17:35]

That's the name of the method. Used to patch the prototype of obj.

+            var methods,
+            List arguments) {
+  String tag = getTypeNameOf(obj);
+  var method = JS('var', '#[#]', methods, tag);
+
+  if (method === null && _dynamicMetadata !== null) {

[ahe, 2012/03/26 14:57:28]

What is _dynamicMetadata and how does it relate to the documentation comment of
this method?

[ngeoffray, 2012/03/27 09:17:35]

I updated the comment.

+    for (int i = 0; i < _dynamicMetadata.length; i++) {
+      MetaInfo entry = _dynamicMetadata[i];
+      if (entry.set.contains(tag)) {
+        method = JS('var', '#[#]', methods, entry.tag);
+        if (method !== null) break;
+      }
+    }
+  }
+
+  if (method === null) {
+    method = JS('var', "#['Object']", methods);
+  }
+
+  if (method === null) {
+    method = JS('var',
+        'function () {'
+          '#(#, #, Array.prototype.slice.call(arguments));'

[ahe, 2012/03/26 14:57:28]

Would this work: new List.from(arguments)
We could change List.from to call slice.

[ngeoffray, 2012/03/27 09:17:35]

I'm not sure I want to mix regular code that calls new List, with code that
deals with the arguments array, which is very special, and may be treated
differently by the JS engines.

[ahe, 2012/03/27 09:42:08]

I would find this code easier to understand if it was something like:

copyArgumentsArray(arguments) {
  return JS('List', 'Array.prototype.slice.call(#)', arguments);
}

But since you need to generate a JS function, I'm not sure my suggestion is
helpful.

[ngeoffray, 2012/03/27 10:37:33]

I could change it to:

'#(#, #, #(arguments));', DART_CLOSURE_TO_JS(throwNoSuchMethod), obj, name,
DART_CLOSURE_TO_JS(copyArgumentsArray)

Let me know what you prefer. Having too much # may hurt readability.

+        '}',
+      DART_CLOSURE_TO_JS(throwNoSuchMethod), obj, name);
+  }
+
+  var nullCheckMethod = JS('var',
+      'function() {'
+        'var res = #.apply(this, Array.prototype.slice.call(arguments));'
+        'return res === null ? (void 0) : res;'
+      '}',
+    method);
+
+  var proto = JS('var', 'Object.getPrototypeOf(#)', obj);
+  if (JS('bool', '!#.hasOwnProperty(#)', proto, name)) {
+    defineProperty(proto, name, nullCheckMethod);
+  }
+
+  return JS('var', '#.apply(#, #)', nullCheckMethod, obj, arguments);
+}
+
+/**
+ * Code for doing the dynamic dispatch on JavaScript prototypes that are not
+ * available at compile-time. Each property of a native Dart class
+ * is registered through this function, which is called with the
+ * following pattern:
+ *
+ * dynamicFunction('propertyName').prototypeName = // JS code
+ *
+ * What this function does is:
+ * - Creates a map of { prototypeName: JS code }.
+ * - Attaches 'propertyName' to the JS Object prototype that will
+ *   intercept at runtime all calls to propertyName.
+ * - Sets the value of 'propertyName' to the returned method from
+ *   [dynamicBind].
+ *
+ */
+dynamicFunction(name) {
+  var f = JS('var', 'Object.prototype[#]', name);
+  if (f !== null && JS('bool', '#.methods', f)) {

[ahe, 2012/03/26 14:57:28]

I doubt that #.methods is a boolean.

[ngeoffray, 2012/03/27 09:17:35]

Done.

+    return JS('var', '#.methods', f);
+  }
+
+  // TODO(ngeoffray): We could make this a map if the code we
+  // generate plays well with a Dart map.
+  var methods = JS('var', '{}');
+  // If there is a method attached to the Dart Object class, use it as
+  // the method to call in case no method is registered for that type.
+  var dartMethod = JS('var', 'Object.getPrototypeOf(#)[#]', new Object(), name);
+  if (dartMethod !== null) JS('void', "#['Object'] = #", methods, dartMethod);
+
+  var bind = JS('var',
+      'function() {'
+        'return #(this, #, #, Array.prototype.slice.call(arguments));'
+      '}',
+    DART_CLOSURE_TO_JS(dynamicBind), name, methods);
+
+  JS('void', '#.methods = #', bind, methods);
+  defineProperty(JS('var', 'Object.prototype'), name, bind);
+  return methods;
+}
+
+
+class MetaInfo {

[ahe, 2012/03/26 14:57:28]

Exactly what information is this information about?

[ngeoffray, 2012/03/27 09:17:35]

Added a comment.

+  String tag;
+  String tags;
+  Set<String> set;
+  MetaInfo(this.tag, this.tags, this.set);
+}
+
+List<MetaInfo> get _dynamicMetadata() {
+  return JS('var', '\$dynamicMetadata');
+}
+
+void set _dynamicMetadata(List<String> table) {
+  return JS('void', '\$dynamicMetadata = #', table);

[ahe, 2012/03/26 14:57:28]

Do you really need to return from here?

[ngeoffray, 2012/03/27 09:17:35]

No, return removed.

+}
+
+/**
+ * Builds the metadata used for encoding the class hierarchy of native
+ * classes.

[ahe, 2012/03/26 14:57:28]

Add example?

[ngeoffray, 2012/03/27 09:17:35]

Done.

+ */
+void dynamicSetMetadata(List<List<String>> inputTable) {
+  _dynamicMetadata = <MetaInfo>[];
+  for (int i = 0; i < inputTable.length; i++) {
+    String tag = inputTable[i][0];
+    String tags = inputTable[i][1];
+    Set<String> set = new Set<String>();
+    List<String> tagNames = tags.split('|');
+    for (int j = 0; j < tagNames.length; j++) {
+      set.add(tagNames[j]);
+    }
+    _dynamicMetadata.add(new MetaInfo(tag, tags, set));
+  }
+}
+
+var isChecksHelper;

[ahe, 2012/03/26 14:57:28]

What is this for and who initializes it?

[ngeoffray, 2012/03/27 09:17:35]

It's a Js object initialized by the compiler. It will be removed soon:
http://codereview.chromium.org/9773026/

[ahe, 2012/03/27 09:42:08]

Add TODO?

+
+// This method will be called for 'is' checks on native types.
+// It takes the object on which the 'is' check is being done, and the
+// property name for the type check. The method patches the real
+// prototype of the object with the value from the Dart object
+// (see [generateNativeClass]).
+bool dynamicIsCheck(obj, String typeName) {
+  if (isJsArray(obj)) return false;
+  // Check if the Dart object corresponding to this class has the property.
+  var res = JS('bool', '!!#[#][#]', isChecksHelper, getTypeNameOf(obj),
+      typeName);
+  var proto = JS('var', 'Object.getPrototypeOf(#)', obj);
+  defineProperty(proto, typeName, res);
+  return res;
+}