Dartium typed js interop work dart repo side of the change. Also tries to get

sdk/lib/js/dartium/js_dartium.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:collection' show ListMixin;
 import 'dart:nativewrappers';
 import 'dart:math' as math;
 import 'dart:mirrors' as mirrors;
 import 'dart:html' as html;
+import 'dart:indexed_db' as indexed_db;
+import 'dart:typed_data';
 
 // Pretend we are always in checked mode as we aren't interested in users
 // running Dartium code outside of checked mode.
 final bool CHECK_JS_INVOCATIONS = true;
 
 final _allowedMethods = new Map<Symbol, _DeclarationSet>();
 final _allowedGetters = new Map<Symbol, _DeclarationSet>();
 final _allowedSetters = new Map<Symbol, _DeclarationSet>();
 
 final _jsInterfaceTypes = new Set<Type>();
@@ skipping 92 matching lines @@
     _members.add(mirror);
   }
 
   final List<mirrors.DeclarationMirror> _members;
 }
 
 /**
  * Temporary method that we hope to remove at some point. This method should
  * generally only be called by machine generated code.
  */
-void registerJsInterfaces(List<Type> classes) {
-  if (_finalized == true) {
-    throw 'JSInterop class registration already finalized';
-  }
+
+void registerJsInterfaces([List<Type> classes]) {
+  // This method is now obsolete in Dartium.
+}
+
+void _registerJsInterfaces(List<Type> classes) {
   for (Type type in classes) {
     if (!_jsInterfaceTypes.add(type)) continue; // Already registered.
     mirrors.ClassMirror typeMirror = mirrors.reflectType(type);
     typeMirror.declarations.forEach((symbol, declaration) {
       if (declaration is mirrors.MethodMirror ||
           declaration is mirrors.VariableMirror && !declaration.isStatic) {
         bool treatAsGetter = false;
         bool treatAsSetter = false;
         if (declaration is mirrors.VariableMirror) {
           treatAsGetter = true;
@@ skipping 24 matching lines @@
               .putIfAbsent(symbol, () => new _DeclarationSet())
               .add(declaration);
         }
       }
     });
   }
 }
 
 _finalizeJsInterfaces() native "Js_finalizeJsInterfaces";
 
+String _getJsName(mirrors.DeclarationMirror mirror) {
+  for (var annotation in mirror.metadata) {
+    if (mirrors.MirrorSystem.getName(annotation.type.simpleName) == "Js") {
+      mirrors.LibraryMirror library = annotation.type.owner;
+      var uri = library.uri;
+      // make sure the annotation is from package://js
+      if (uri.scheme == 'package' && uri.path == 'js/js.dart') {
+        try {
+          var name = annotation.reflectee.name;
+          return name != null ? name : "";
+        } catch (e) {
+        }
+      }
+    }
+  }
+  return null;
+}
+
+bool _hasJsName(mirrors.DeclarationMirror mirror) =>
+  _getJsName(mirror) != null;
+
+
+_getJsMemberName(mirrors.DeclarationMirror mirror) {
+  var name = _getJsName(mirror);
+  return name == null || name.isEmpty ? _getDeclarationName(mirror) :
+      name;
+}
+
+// TODO(jacobr): handle setters correctyl.
+String _getDeclarationName(mirrors.DeclarationMirror declaration) {
+  var name = mirrors.MirrorSystem.getName(declaration.simpleName);
+  if (declaration is mirrors.MethodMirror && declaration.isSetter) {
+    assert(name.endsWith("="));
+    name = name.substring(0, name.length - 1);
+  }
+  return name;
+}
+
+final _JS_LIBRARY_PREFIX = "js_library";
+final _UNDEFINED_VAR = "_UNDEFINED_JS_CONST";
+
+String _accessJsPath(String path) =>
+    "${_JS_LIBRARY_PREFIX}.context${path.split(".").map((p) => "['$p']").join('')}";
+
+void addMemberHelper(mirrors.MethodMirror declaration, String path, StringBuffer sb, {bool isStatic: false, String memberName}) {
+  var jsName = _getJsMemberName(declaration);
+  path = (path != null && path.isNotEmpty) ? "${path}.${jsName}" : jsName;
+  var name = memberName != null ? memberName : _getDeclarationName(declaration);
+  if (declaration.isConstructor) {
+    sb.write("factory");
+  } else if (isStatic) {
+    sb.write("static");
+  } else {
+    sb.write("patch");
+  }
+  sb.write(" ");
+  if (declaration.isGetter) {
+    sb.write("get $name => ${_accessJsPath(path)};");
+  } else if (declaration.isSetter) {
+    sb.write("set $name(v) => ${_accessJsPath(path)} = v;");
+  } else {
+    sb.write("$name(");
+    bool hasOptional = false;
+    int i = 0;
+    var args = <String>[];
+    for (var p in declaration.parameters) {
+      assert(!p.isNamed); // XXX throw
+      assert(!p.hasDefaultValue);
+      if (i > 0) {
+        sb.write(", ");
+      }
+      if (p.isOptional && !hasOptional) {
+        sb.write("[");
+        hasOptional = true;
+      }
+      var arg = "p$i";
+      args.add(arg);
+      sb.write(arg);
+      if (p.isOptional) {
+        sb.write("=${_UNDEFINED_VAR}");
+      }
+      i++;
+    }
+    if (hasOptional) {
+      sb.write("]");
+    }
+    // TODO(jacobr):
+    sb.write(") => ");
+    if (declaration.isConstructor) {
+        sb.write("new ${_JS_LIBRARY_PREFIX}.JsObject(");
+    }
+    sb
+      ..write(_accessJsPath(path))
+      ..write(declaration.isConstructor ? "," : ".apply(")
+      ..write("[${args.join(",")}]");
+
+    if (hasOptional) {
+      sb.write(".takeWhile((i) => i != ${_UNDEFINED_VAR}).toList()");
+    }
+    sb.write(");");
+  }
+  sb.write("\n");
+}
+
+// TODO(jacobr): make this check more robust.
+bool _isExternal(mirrors.MethodMirror mirror) =>
+    mirror.source != null && mirror.source.startsWith("external ");
+
+List<String> _generateExternalMethods() {
+  var staticCodegen = <String>[];
+  mirrors.currentMirrorSystem().libraries.forEach((uri, library) {
+    var sb = new StringBuffer();
+    String jsLibraryName = _getJsName(library);
+    library.declarations.forEach((name, declaration) {
+      if (declaration is mirrors.MethodMirror) {
+        if (_isExternal(declaration) && (_hasJsName(declaration) || jsLibraryName != null)) {
+          addMemberHelper(declaration, jsLibraryName, sb);
+        }
+      } else if (declaration is mirrors.ClassMirror) {
+        mirrors.ClassMirror clazz = declaration;
+        if (_hasJsName(clazz)) {
+          // TODO(jacobr): verify class implements JavaScriptObject.
+          assert(clazz.hasReflectedType);
+          jsInterfaceTypes.add(clazz.reflectedType);
+          String jsClassName = _getJsMemberName(clazz);
+          var className = mirrors.MirrorSystem.getName(clazz.simpleName);
+          var sbPatch = new StringBuffer();
+          clazz.declarations.forEach((name, declaration) {
+            if (declaration is! mirrors.MethodMirror || !_isExternal(declaration)) return;
+            if (declaration.isFactoryConstructor) {
+              sbPatch.write("  factory ${className}({");
+              int i = 0;
+              var args = <String>[];
+              for (var p in declaration.parameters) {
+                assert(p.isNamed); // XXX throw
+                args.add(mirrors.MirrorSystem.getName(p.simpleName));
+                i++;
+              }
+              sbPatch
+                ..write(args.map((name) => '$name:${_UNDEFINED_VAR}').join(", "))
+                ..write("}) {\n"
+                        "    var ret = new ${_JS_LIBRARY_PREFIX}.JsObject.jsify({});\n");
+              i = 0;
+              for (var p in declaration.parameters) {
+                assert(p.isNamed); // XXX throw
+                var name = args[i];
+                var jsName = mirrors.MirrorSystem.getName(p.simpleName);
+                // XXX apply name conversion rules.
+                sbPatch.write("    if($name != ${_UNDEFINED_VAR}) ret['$jsName'] = $name;\n");
+                i++;
+              }
+
+              sbPatch.write("    return ret;\n"
+                            "  }\n");
+            } else if (declaration.isConstructor) {
+              sbPatch.write("  ");
+              addMemberHelper(declaration,
+                  (jsLibraryName != null && jsLibraryName.isNotEmpty) ? "${jsLibraryName}" : "",
+                  sbPatch,
+                  isStatic: true,
+                  memberName: className);
+            }
+          });
+
+          clazz.staticMembers.forEach((memberName, member) {
+            if (_isExternal(member)) {
+              sbPatch.write("  ");
+              addMemberHelper(member,
+                  (jsLibraryName != null && jsLibraryName.isNotEmpty) ? "${jsLibraryName}.${jsClassName}" : jsClassName,
+                  sbPatch,
+                  isStatic: true);
+            }
+          });
+          if (sbPatch.isNotEmpty) {
+            sb.write("""
+patch class $className {
+$sbPatch
+}
+""");
+          }
+        }
+      }
+    });
+    if (sb.isNotEmpty) {
+      staticCodegen
+        ..add(uri.toString())
+        ..add("${uri}_js_interop_patch.dart")
+        ..add("""
+import 'dart:js' as ${_JS_LIBRARY_PREFIX};
+
+/**
+ * Placeholder object for cases where we need to determine exactly how many
+ * args were passed to a function.
+ */
+const ${_UNDEFINED_VAR} = const Object();
+
+${sb}
+""");
+    }
+  });
+
+  return staticCodegen;
+}
+
 /**
  * Generates a part file defining source code for JsObjectImpl and related
  * classes. This calass is needed so that type checks for all registered JavaScript
  * interop classes pass.
  */
-String _generateJsObjectImplPart() {
-  Iterable<Type> types = jsInterfaceTypes;
+List<String> _generateInteropPatchFiles() {
+  var ret = _generateExternalMethods();
   var libraryPrefixes = new Map<mirrors.LibraryMirror, String>();
   var prefixNames = new Set<String>();
   var sb = new StringBuffer();
 
   var implements = <String>[];
-  for (var type in types) {
+  var implementsArray = <String>[];
+  var listMirror = mirrors.reflectType(List);
+
+  for (var type in jsInterfaceTypes) {
     mirrors.ClassMirror typeMirror = mirrors.reflectType(type);
     mirrors.LibraryMirror libraryMirror = typeMirror.owner;
     var prefixName;
     if (libraryPrefixes.containsKey(libraryMirror)) {
       prefixName = libraryPrefixes[libraryMirror];
     } else {
       var basePrefixName =
           mirrors.MirrorSystem.getName(libraryMirror.simpleName);
       basePrefixName = basePrefixName.replaceAll('.', '_');
       if (basePrefixName.isEmpty) basePrefixName = "lib";
       prefixName = basePrefixName;
       var i = 1;
       while (prefixNames.contains(prefixName)) {
         prefixName = '$basePrefixName$i';
         i++;
       }
       prefixNames.add(prefixName);
       libraryPrefixes[libraryMirror] = prefixName;
     }
-    implements.add(
+    var isArray = typeMirror.isSubtypeOf(listMirror);
+    (isArray ? implementsArray : implements).add(
         '${prefixName}.${mirrors.MirrorSystem.getName(typeMirror.simpleName)}');
   }
   libraryPrefixes.forEach((libraryMirror, prefix) {
     sb.writeln('import "${libraryMirror.uri}" as $prefix;');
   });
-  var implementsClause =
-      implements.isEmpty ? "" : "implements ${implements.join(', ')}";
+  buildImplementsClause(classes) =>
+      classes.isEmpty ? "" : "implements ${classes.join(', ')}"
+  var implementsClause = buildImplementsClause(implements);
   // TODO(jacobr): only certain classes need to be implemented by
-  // Function and Array.
+  // JsFunctionImpl.
+  var allTypes = []..addAll(implements)..addAll(implementsArray);
   sb.write('''
 class JsObjectImpl extends JsObject $implementsClause {
   JsObjectImpl.internal() : super.internal();
 }
 
 class JsFunctionImpl extends JsFunction $implementsClause {
   JsFunctionImpl.internal() : super.internal();
 }
 
-class JsArrayImpl<E> extends JsArray<E> $implementsClause {
+class JsArrayImpl<E> extends JsArray<E> ${buildImplementsClause(implementsArray)} {
   JsArrayImpl.internal() : super.internal();
 }
+
+_registerAllJsInterfaces() {
+  _registerJsInterfaces([${allTypes.join(", ")}]);
+}
+
 ''');
-  return sb.toString();
+  ret..addAll(["dart:js", "JsInteropImpl.dart", sb.toString()]);
+  return ret;
 }
 
 // Start of block of helper methods facilitating emulating JavaScript Array
 // methods on Dart List objects passed to JavaScript via JS interop.
 // TODO(jacobr): match JS more closely.
 String _toStringJs(obj) => '$obj';
 
 // TODO(jacobr): this might not exactly match JS semantics but should be
 // adequate for now.
 int _toIntJs(obj) {
@@ skipping 151 matching lines @@
 
 bool get _finalized native "Js_interfacesFinalized_Callback";
 
 JsObject get context {
   if (_cachedContext == null) {
     _cachedContext = _context;
   }
   return _cachedContext;
 }
 
+_maybeWrap(o) {
+  var wrapped = html.wrap_jso_no_SerializedScriptvalue(o);
+  if (identical(wrapped, o)) return o;
+  return (wrapped is html.Blob
+      || wrapped is html.Event
+      || wrapped is indexed_db.KeyRange
+      || wrapped is html.ImageData
+      || wrapped is html.Node
+      || wrapped is TypedData
+      || wrapped is html.Window) ? wrapped : o;
+}
+
 /**
  * Get the dart wrapper object for object. Top-level so we
  * we can access it from other libraries without it being
  * a public instance field on JsObject.
  */
 getDartHtmlWrapperFor(JsObject object) => object._dartHtmlWrapper;
 
 /**
  * Set the dart wrapper object for object. Top-level so we
  * we can access it from other libraries without it being
  * a public instance field on JsObject.
  */
 void setDartHtmlWrapperFor(JsObject object, wrapper) {
   object._dartHtmlWrapper = wrapper;
 }
 
 /**
  * Used by callMethod to get the JS object for each argument passed if the
  * argument is a Dart class instance that delegates to a DOM object.  See
  * wrap_jso defined in dart:html.
  */
 unwrap_jso(dartClass_instance) {
-  try {
-    if (dartClass_instance != null)
-      return dartClass_instance is NativeFieldWrapperClass2 ?
-          dartClass_instance.blink_jsObject : dartClass_instance;
-    else
-      return null;
-  } catch(NoSuchMethodException) {
-    // No blink_jsObject then return the dartClass_instance is probably an
-    // array that was already converted to a Dart class e.g., Uint8ClampedList.
+  if (dartClass_instance is NativeFieldWrapperClass2 && dartClass_instance is! JsObject)
+    return dartClass_instance.blink_jsObject;
+  else
     return dartClass_instance;
-  }
 }
 
 /**
  * Proxies a JavaScript object to Dart.
  *
  * The properties of the JavaScript object are accessible via the `[]` and
  * `[]=` operators. Methods are callable via [callMethod].
  */
 class JsObject extends NativeFieldWrapperClass2 {
   JsObject.internal();
@@ skipping 72 matching lines @@
   static JsObject _fromBrowserObject(object) => html.unwrap_jso(object);
 
   /**
    * Returns the value associated with [property] from the proxied JavaScript
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
   operator [](property) {
     try {
-      return _operator_getter(property);
+      return _maybeWrap(_operator_getter(property));
     } catch (e) {
       // Re-throw any errors (returned as a string) as a DomException.
       throw new html.DomException.jsInterop(e);
     }
   }
   _operator_getter(property) native "JsObject_[]";
 
   /**
    * Sets the value associated with [property] on the proxied JavaScript
    * object.
@@ skipping 60 matching lines @@
   String _toString() native "JsObject_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].
    */
   callMethod(String method, [List args]) {
     try {
-      if (args != null) {
-        for (var i = 0; i < args.length; i++)
-          args[i] = unwrap_jso(args[i]);
-      }
-      return _callMethod(method, args);
+      return _maybeWrap(_callMethod(method, args));
     } catch (e) {
       if (hasProperty(method)) {
         // Return a DomException if DOM call returned an error.
         throw new html.DomException.jsInterop(e);
       } else {
         throw new NoSuchMethodError(this, new Symbol(method), args, null);
       }
     }
   }
 
@@ skipping 43 matching lines @@
       if (CHECK_JS_INVOCATIONS) {
         if (!matches._checkReturnType(ret)) throwError();
       }
       return ret;
     }
   }
 
   _callMethod(String name, List args) native "JsObject_callMethod";
 }
 
+// JavaScript interop methods that do not automatically wrap to dart:html types.
+// Warning: this API is not exposed to dart:js.
+class JsNative {
+  static getProperty(JsObject o, name) {
+    return o._operator_getter(name);
+  }
+
+  static callMethod(JsObject o, String method, List args) {
+    return o._callMethod(method, args);
+  }
+
+  static getArrayIndex(JsArray array, int index) {
+    array._checkIndex(index);
+    return getProperty(array, index);
+  }
+
+  /**
+   * Same behavior as new JsFunction.withThis except that JavaScript "this" is not
+   * wrapped.
+   */
+  static JsFunction withThis(Function f) native "JsFunction_withThisNoWrap";
+}
+
 /**
  * Proxies a JavaScript Function object.
  */
 class JsFunction extends JsObject implements Function {
   JsFunction.internal() : super.internal();
 
   /**
    * 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) => _withThis(f);
 
   /**
    * 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}) native "JsFunction_apply";
+  dynamic apply(List args, {thisArg}) =>
+    _maybeWrap(_apply(args, thisArg: thisArg));
+
+  dynamic _apply(List args, {thisArg}) native "JsFunction_apply";
 
   noSuchMethod(Invocation invocation) {
     if (invocation.isMethod && invocation.memberName == #call) {
       return apply(_buildArgs(invocation));
     }
     return super.noSuchMethod(invocation);
   }
 
   /**
    * Internal only version of apply which uses debugger proxies of Dart objects
@@ skipping 121 matching lines @@
 
 /**
  * Returns a method that can be called with an arbitrary number (for n less
  * than 11) of arguments without violating Dart type checks.
  */
 Function _wrapAsDebuggerVarArgsFunction(JsFunction jsFunction) =>
     ([a1 = _UNDEFINED, a2 = _UNDEFINED, a3 = _UNDEFINED, a4 = _UNDEFINED,
         a5 = _UNDEFINED, a6 = _UNDEFINED, a7 = _UNDEFINED, a8 = _UNDEFINED,
         a9 = _UNDEFINED, a10 = _UNDEFINED]) => jsFunction._applyDebuggerOnly(
             _stripUndefinedArgs([a1, a2, a3, a4, a5, a6, a7, a8, a9, a10]));
+
+// This method is a no-op in Dartium.
+// TODO(jacobr): tag methods so we can throw if a Dart method is passed to
+// JavaScript using the new interop without calling allowInterop.
+Function allowInterop(Function f) => f;
+
+Expando<JsFunction> _interopCaptureThisExpando = new Expando<JsFunction>();
+
+Function allowInteropCaptureThis(Function f) {
+  if (f is JsFunction) {
+    // 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 {
+    var ret = _interopCaptureThisExpando[f];
+    if (ret == null) {
+      ret = new JsFunction.withThis(f);
+      _interopCaptureThisExpando[f] = ret;
+    }
+    return ret;
+  }
+}