Utility class of static methods to efficiently manipulate typed JSInterop objects in a dynamic mann…

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 88 matching lines @@
 import 'dart:core';
 
 import 'cached_patches.dart';
 
 // Pretend we are always in checked mode as we aren't interested in users
 // running Dartium code outside of checked mode.
 @Deprecated("Internal Use Only")
 final bool CHECK_JS_INVOCATIONS = true;
 
 final String _DART_RESERVED_NAME_PREFIX = r'JS$';
+// If a private class is defined to use @JS we need to inject a non-private
+// class with a name that will not cause collisions in the library so we can
+// make JSObject implement that interface even though it is in a different
+// library.
+final String escapePrivateClassPrefix = r'$JSImplClass23402893498';

[Alan Knight, 2016/07/19 16:56:16]

Is this a problem if there are two different private classes, in separate
libraries, but both visible, that have the same name?

[Jacob, 2016/07/19 17:36:40]

No because all libraries are imported into the dart:js patch file using
prefixes.

 
 String _stripReservedNamePrefix(String name) =>
     name.startsWith(_DART_RESERVED_NAME_PREFIX)
         ? name.substring(_DART_RESERVED_NAME_PREFIX.length)
         : name;
 
 _buildArgs(Invocation invocation) {
   if (invocation.namedArguments.isEmpty) {
     return invocation.positionalArguments;
   } else {
@@ skipping 214 matching lines @@
       // is file://dart/sdk/lib/html/html_common/metadata.dart
       // instead of a proper dart: location.
       return true;
     }
   }
   return false;
 }
 
 _getJsMemberName(mirrors.DeclarationMirror mirror) {
   var name = _getJsName(mirror);
-  return name == null || name.isEmpty ? _getDeclarationName(mirror) : name;
+  return name == null || name.isEmpty ? _stripReservedNamePrefix(_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 _stripReservedNamePrefix(name);
+  return name;
 }
 
 final _JS_LIBRARY_PREFIX = "js_library";
 final _UNDEFINED_VAR = "_UNDEFINED_JS_CONST";
 
 String _accessJsPath(String path) => _accessJsPathHelper(path.split("."));
 
 String _accessJsPathHelper(Iterable<String> parts) {
   var sb = new StringBuffer();
   sb
@@ skipping 153 matching lines @@
             _isExternal(declaration)) {
           addMemberHelper(declaration, jsLibraryName, sb);
         }
       } else if (declaration is mirrors.ClassMirror) {
         mirrors.ClassMirror clazz = declaration;
         var isDom = dartLibrary ? hasDomName(clazz) : false;
         var isJsInterop = _hasJsName(clazz);
         if (isDom || isJsInterop) {
           // TODO(jacobr): verify class implements JavaScriptObject.
           var className = mirrors.MirrorSystem.getName(clazz.simpleName);
+          bool isPrivate = className.startsWith('_');
           var classNameImpl = '${className}Impl';
           var sbPatch = new StringBuffer();
           if (isJsInterop) {
             String jsClassName = _getJsMemberName(clazz);
 
             jsInterfaceTypes.add(clazz);
             clazz.declarations.forEach((name, declaration) {
               if (declaration is! mirrors.MethodMirror ||
                   !_isExternal(declaration)) return;
               if (declaration.isFactoryConstructor &&
@@ skipping 54 matching lines @@
                         ? "${jsLibraryName}.${jsClassName}"
                         : jsClassName,
                     sbPatch,
                     isStatic: true);
               }
             });
           }
           if (isDom) {
             sbPatch.write("  static Type get instanceRuntimeType => ${classNameImpl};\n");
           }
+          if (isPrivate) {
+            sb.write("""
+class ${escapePrivateClassPrefix}${className} implements $className {}
+""");
+          }
+
           if (sbPatch.isNotEmpty) {
             var typeVariablesClause = '';
             if (!clazz.typeVariables.isEmpty) {
               typeVariablesClause =
                   '<${clazz.typeVariables.map((m) => mirrors.MirrorSystem.getName(m.simpleName)).join(',')}>';
             }
             sb.write("""
 patch class $className$typeVariablesClause {
 $sbPatch
 }
@@ skipping 87 matching lines @@
       while (prefixNames.contains(prefixName)) {
         prefixName = '$basePrefixName$i';
         i++;
       }
       prefixNames.add(prefixName);
       libraryPrefixes[libraryMirror] = prefixName;
     }
     var isArray = typeMirror.isSubtypeOf(listMirror);
     var isFunction = typeMirror.isSubtypeOf(functionMirror);
     var isJSObject = typeMirror.isSubtypeOf(jsObjectMirror);
+    var className = mirrors.MirrorSystem.getName(typeMirror.simpleName);
+    var isPrivate = className.startsWith('_');
+    if (isPrivate) className = '${escapePrivateClassPrefix}${className}';
     var fullName =
-        '${prefixName}.${mirrors.MirrorSystem.getName(typeMirror.simpleName)}';
+        '${prefixName}.${className}';
     (isArray ? implementsArray : implements).add(fullName);
     if (!isArray && !isFunction && !isJSObject) {
       // For DOM classes we need to be a bit more conservative at tagging them
       // as implementing JS inteorp classes risks strange unintended
       // consequences as unrleated code may have instanceof checks.  Checking
       // for isJSObject ensures we do not accidentally pull in existing
       // dart:html classes as they all have JSObject as a base class.
       // Note that methods from these classes can still be called on a
       // dart:html instance but checked mode type checks will fail. This is
       // not ideal but is better than causing strange breaks in existing
@@ skipping 602 matching lines @@
 
   static toTypedObject(JsObject o) native "JSNative_toTypedObject";
 
   /**
    * Same behavior as new JsFunction.withThis except that JavaScript "this" is not
    * wrapped.
    */
   static JSFunction withThis(Function f) native "JsFunction_withThisNoWrap";
 }
 
+/// Utility methods to efficiently manipulate typed JSInterop objects in cases
+/// where the name to call is not known at runtime. You should only use these
+/// methods when the same effect cannot be achieved with @JS annotations.
+/// These methods would be extension methods on JSObject if Dart supported
+/// extension methods.
+class JSNative {
+   /**
+    * WARNING: performance of this method is much worse than other methods
+    * in JSNative. Only use this method as a last resort.
+    *
+    * 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.
+    * Primitives and other transferrable values are directly converted to their
+    * JavaScript type, and all other objects are proxied.
+    */
+  static jsify(object) {
+    if ((object is! Map) && (object is! Iterable)) {
+      throw new ArgumentError("object must be a Map or Iterable");
+    }
+    return _jsify(object);
+  }
+
+  static _jsify(object) native "JSObject_jsify";
+  static JSObject newObject() native "JSObject_newObject";
+
+  static hasProperty(JSObject o, name) => o._hasProperty(name);
+  static getProperty(JSObject o, name) => o._operator_getter(name);
+  static setProperty(JSObject o, name, value) => o._operator_setter(name, value);
+  static callMethod(JSObject o, String method, List args) => o._callMethod(method, args);
+  static instanceof(JSObject o, Function type) => o._instanceof(type);
+  static callConstructor(JSObject constructor, List args) native "JSNative_callConstructor";
+}
 
 /**
  * Proxies a JavaScript Function object.
  */
 class JsFunction extends JsObject {
   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.
@@ skipping 214 matching lines @@
   } else {
     var ret = _interopCaptureThisExpando[f];
     if (ret == null) {
       // TODO(jacobr): we could optimize this.
       ret = JSFunction._createWithThis(f);
       _interopCaptureThisExpando[f] = ret;
     }
     return ret;
   }
 }
-
-debugPrint(_) {}