Support isExternal method on MethodMirror in the Dart VM. Not really intended for public consumptio…

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 86 matching lines @@
 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>();
-Iterable<Type> get jsInterfaceTypes => _jsInterfaceTypes;
+final _jsInterfaceTypes = new Set<mirrors.ClassMirror>();
+Iterable<mirrors.ClassMirror> get jsInterfaceTypes => _jsInterfaceTypes;
 
 /// A collection of methods where all methods have the same name.
 /// This class is intended to optimize whether a specific invocation is
 /// appropritate for at least some of the methods in the collection.
 class _DeclarationSet {
   _DeclarationSet() : _members = <mirrors.DeclarationMirror>[];
 
   static bool _checkType(obj, mirrors.TypeMirror type) {
     if (obj == null) return true;
     return mirrors.reflectType(obj.runtimeType).isSubtypeOf(type);
@@ skipping 87 matching lines @@
 /**
  * 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]) {
   // 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;
           if (!declaration.isConst && !declaration.isFinal) {
             treatAsSetter = true;
@@ skipping 32 matching lines @@
 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) {
-        }
+        } catch (e) {}
       }
     }
   }
   return null;
 }
 
-bool _hasJsName(mirrors.DeclarationMirror mirror) =>
-  _getJsName(mirror) != null;
+bool _isAnonymousClass(mirrors.ClassMirror mirror) {
+  for (var annotation in mirror.metadata) {
+    if (mirrors.MirrorSystem.getName(annotation.type.simpleName) ==
+        "_Anonymous") {
+      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') {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 
+bool _hasJsName(mirrors.DeclarationMirror mirror) => _getJsName(mirror) != null;
 
 _getJsMemberName(mirrors.DeclarationMirror mirror) {
   var name = _getJsName(mirror);
-  return name == null || name.isEmpty ? _getDeclarationName(mirror) :
-      name;
+  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('')}";
 
 @Deprecated("Internal Use Only")
-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;
+void addMemberHelper(
+    mirrors.MethodMirror declaration, String path, StringBuffer sb,
+    {bool isStatic: false, String memberName}) {
+  if (!declaration.isConstructor) {
+    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) {
@@ skipping 22 matching lines @@
         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("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 ");
+bool _isExternal(mirrors.Mirror mirror) {
+  /*
+  var source = mirror.source;
+  return source != null && source.startsWith("external ");
+  */
+  return mirror.isExternal;
+}
 
 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)) {
+        if ((_hasJsName(declaration) || jsLibraryName != null) &&
+            _isExternal(declaration)) {
           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();
+          jsInterfaceTypes.add(clazz);
           clazz.declarations.forEach((name, declaration) {
-            if (declaration is! mirrors.MethodMirror || !_isExternal(declaration)) return;
-            if (declaration.isFactoryConstructor) {
+            if (declaration is! mirrors.MethodMirror ||
+                !_isExternal(declaration)) return;
+            if (declaration.isFactoryConstructor && _isAnonymousClass(clazz)) {
               sbPatch.write("  factory ${className}({");
               int i = 0;
               var args = <String>[];
+              for (var p in declaration.parameters) {
+                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 ||
+                declaration.isFactoryConstructor) {
+              sbPatch.write("  ");
+              addMemberHelper(
+                  declaration,
+                  (jsLibraryName != null && jsLibraryName.isNotEmpty)
+                      ? "${jsLibraryName}.${jsClassName}"
+                      : jsClassName,
+                  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);
+            }
+          });
+          var typeVariablesClause = '';
+          if (!clazz.typeVariables.isEmpty) {
+            typeVariablesClause =
+                '<${clazz.typeVariables.map((m) => mirrors.MirrorSystem.getName(m.simpleName)).join(',')}>';
+          }
+          if (sbPatch.isNotEmpty) {
+            sb.write("""
+patch class $className$typeVariablesClause {
+$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;
+}
+
+List<String> _generateExternalMethods2() {
+  var staticCodegen = <String>[];
+  mirrors.currentMirrorSystem().libraries.forEach((uri, library) {
+    var sb = new StringBuffer();
+    String jsLibraryName = _getJsName(library);
+    library.declarations.forEach((name, declaration) {
+      var isExternal = _isExternal(declaration);
+      if (declaration is mirrors.MethodMirror) {
+        if (isExternal && (_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.
+          String jsClassName = _getJsMemberName(clazz);
+          var className = mirrors.MirrorSystem.getName(clazz.simpleName);
+          var sbPatch = new StringBuffer();
+          jsInterfaceTypes.add(clazz);
+          clazz.declarations.forEach((name, declaration) {
+            if (declaration is! mirrors.MethodMirror ||
+                !declaration.isAbstract ||
+                !isExternal) return;
+            if (_hasLiteralAnnotation(declaration) &&
+                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(
+                    args.map((name) => '$name:${_UNDEFINED_VAR}').join(", "))
                 ..write("}) {\n"
-                        "    var ret = new ${_JS_LIBRARY_PREFIX}.JsObject.jsify({});\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");
+                sbPatch.write(
+                    "    if($name != ${_UNDEFINED_VAR}) ret['$jsName'] = $name;\n");
                 i++;
               }
 
               sbPatch.write("    return ret;\n"
-                            "  }\n");
-            } else if (declaration.isConstructor) {
+                  "  }\n");
+            } else if (declaration.isConstructor ||
+                declaration.isFactoryConstructor) {
               sbPatch.write("  ");
-              addMemberHelper(declaration,
-                  (jsLibraryName != null && jsLibraryName.isNotEmpty) ? "${jsLibraryName}" : "",
+              addMemberHelper(
+                  declaration,
+                  (jsLibraryName != null && jsLibraryName.isNotEmpty)
+                      ? "${jsLibraryName}.${jsClassName}"
+                      : jsClassName,
                   sbPatch,
                   isStatic: true,
                   memberName: className);
             }
           });
 
           clazz.staticMembers.forEach((memberName, member) {
             if (_isExternal(member)) {
               sbPatch.write("  ");
-              addMemberHelper(member,
-                  (jsLibraryName != null && jsLibraryName.isNotEmpty) ? "${jsLibraryName}.${jsClassName}" : jsClassName,
+              addMemberHelper(
+                  member,
+                  (jsLibraryName != null && jsLibraryName.isNotEmpty)
+                      ? "${jsLibraryName}.${jsClassName}"
+                      : jsClassName,
                   sbPatch,
                   isStatic: true);
             }
           });
+          var typeVariablesClause = '';
+          if (!clazz.typeVariables.isEmpty) {
+            typeVariablesClause =
+                '<${clazz.typeVariables.map((m) => mirrors.MirrorSystem.getName(m.simpleName)).join(',')}>';
+          }
           if (sbPatch.isNotEmpty) {
             sb.write("""
-patch class $className {
+patch class $className$typeVariablesClause {
 $sbPatch
 }
 """);
           }
         }
       }
     });
     if (sb.isNotEmpty) {
       staticCodegen
         ..add(uri.toString())
@@ skipping 23 matching lines @@
 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>[];
   var implementsArray = <String>[];
   var listMirror = mirrors.reflectType(List);
 
-  for (var type in jsInterfaceTypes) {
-    mirrors.ClassMirror typeMirror = mirrors.reflectType(type);
+  for (var typeMirror in jsInterfaceTypes) {
     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;
     }
     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;');
   });
   buildImplementsClause(classes) =>
-      classes.isEmpty ? "" : "implements ${classes.join(', ')}"
+      classes.isEmpty ? "" : "implements ${classes.join(', ')}";
   var implementsClause = buildImplementsClause(implements);
   // TODO(jacobr): only certain classes need to be implemented by
   // JsFunctionImpl.
   var allTypes = []..addAll(implements)..addAll(implementsArray);
   sb.write('''
 class JsObjectImpl extends JsObject $implementsClause {
   JsObjectImpl.internal() : super.internal();
 }
 
 class JsFunctionImpl extends JsFunction $implementsClause {
@@ skipping 54 matching lines @@
     sep = ",";
   }
   return list.map((e) => e == null ? "" : e.toString()).join(sep.toString());
 }
 
 // TODO(jacobr): should we really bother with this method instead of just
 // shallow copying to a JS array and using the toString method?
 String _arrayToString(List list) => _arrayJoin(list, ",");
 
 int _arrayPush(List list, List args) {
-  for(var e in args) {
+  for (var e in args) {
     list.add(e);
   }
   return list.length;
 }
 
 _arrayPop(List list) {
   if (list.length > 0) return list.removeLast();
 }
 
 // TODO(jacobr): would it be better to just copy input to a JS List
@@ skipping 103 matching lines @@
 JsObject get context {
   if (_cachedContext == null) {
     _cachedContext = _context;
   }
   return _cachedContext;
 }
 
 _maybeWrap(o) {
   var wrapped = html_common.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;
+  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.
  */
 @Deprecated("Internal Use Only")
 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.
  */
 @Deprecated("Internal Use Only")
 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.
  */
 @Deprecated("Internal Use Only")
 unwrap_jso(dartClass_instance) {
-  if (dartClass_instance is html.DartHtmlDomObject)
-    return dartClass_instance.blink_jsObject;
-  else
-    return dartClass_instance;
+  if (dartClass_instance is html.DartHtmlDomObject &&
+      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();
 
   /**
    * If this JsObject is wrapped, e.g. DOM objects, then we can save the
    * wrapper here and preserve its identity.
    */
   var _dartHtmlWrapper;
 
   /**
    * Constructs a new JavaScript object from [constructor] and returns a proxy
    * to it.
    */
   factory JsObject(JsFunction constructor, [List arguments]) {
     try {
-      return _create(constructor, arguments);
+      return html_common.unwrap_jso(_create(constructor, arguments));
     } catch (e) {
       // Re-throw any errors (returned as a string) as a DomException.
       throw new html.DomException.jsInterop(e);
     }
   }
 
-  static JsObject _create(
-      JsFunction constructor, arguments) native "JsObject_constructorCallback";
+  static JsObject _create(JsFunction constructor, arguments)
+      native "JsObject_constructorCallback";
 
   _buildArgs(Invocation invocation) {
     if (invocation.namedArguments.isEmpty) {
       return invocation.positionalArguments;
     } else {
       var varArgs = new Map<String, Object>();
       invocation.namedArguments.forEach((symbol, val) {
         varArgs[mirrors.MirrorSystem.getName(symbol)] = val;
       });
       return invocation.positionalArguments.toList()
@@ skipping 46 matching lines @@
    * The type of [property] must be either [String] or [num].
    */
   operator [](property) {
     try {
       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.
    *
    * The type of [property] must be either [String] or [num].
    */
   operator []=(property, value) {
     try {
       _operator_setter(property, value);
     } catch (e) {
       // Re-throw any errors (returned as a string) as a DomException.
       throw new html.DomException.jsInterop(e);
     }
   }
+
   _operator_setter(property, value) native "JsObject_[]=";
 
   int get hashCode native "JsObject_hashCode";
 
   operator ==(other) {
     var is_JsObject = other is JsObject;
     if (!is_JsObject) {
       other = html_common.unwrap_jso(other);
       is_JsObject = other is JsObject;
     }
     return is_JsObject && _identityEquality(this, other);
   }
 
-  static bool _identityEquality(
-      JsObject a, JsObject b) native "JsObject_identityEquality";
+  static bool _identityEquality(JsObject a, JsObject b)
+      native "JsObject_identityEquality";
 
   /**
    * 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(String property) native "JsObject_hasProperty";
 
   /**
@@ skipping 129 matching lines @@
    * 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}) =>
-    _maybeWrap(_apply(args, thisArg: 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
    * rather than opaque handles. This method is private because it cannot be
    * efficiently implemented in Dart2Js so should only be used by internal
    * tools.
    */
-  _applyDebuggerOnly(List args,
-      {thisArg}) native "JsFunction_applyDebuggerOnly";
+  _applyDebuggerOnly(List args, {thisArg})
+      native "JsFunction_applyDebuggerOnly";
 
   static JsFunction _withThis(Function f) native "JsFunction_withThis";
 }
 
 /**
  * A [List] proxying a JavaScript Array.
  */
 class JsArray<E> extends JsObject with ListMixin<E> {
   JsArray.internal() : super.internal();
 
   factory JsArray() => _newJsArray();
 
   static JsArray _newJsArray() native "JsArray_newJsArray";
 
   factory JsArray.from(Iterable<E> other) =>
       _newJsArrayFromSafeList(new List.from(other));
 
-  static JsArray _newJsArrayFromSafeList(
-      List list) native "JsArray_newJsArrayFromSafeList";
+  static JsArray _newJsArrayFromSafeList(List list)
+      native "JsArray_newJsArrayFromSafeList";
 
   _checkIndex(int index, {bool insert: false}) {
     int length = insert ? this.length + 1 : this.length;
     if (index is int && (index < 0 || index >= length)) {
       throw new RangeError.range(index, 0, length);
     }
   }
 
   _checkRange(int start, int end) {
     int cachedLength = this.length;
@@ skipping 81 matching lines @@
 
 // TODO(jacobr): this method is a hack to work around the lack of proper dart
 // support for varargs methods.
 List _stripUndefinedArgs(List args) =>
     args.takeWhile((i) => i != _UNDEFINED).toList();
 
 /**
  * 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]));
+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]));
 
 // The allowInterop 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.
 
 /// Returns a wrapper around function [f] that can be called from JavaScript
 /// using the package:js Dart-JavaScript interop.
 ///
 /// For performance reasons in Dart2Js, by default Dart functions cannot be
 /// passed directly to JavaScript unless this method is called to create
@@ skipping 21 matching lines @@
     return f;
   } else {
     var ret = _interopCaptureThisExpando[f];
     if (ret == null) {
       ret = new JsFunction.withThis(f);
       _interopCaptureThisExpando[f] = ret;
     }
     return ret;
   }
 }