Enhance dart:js interop in a backwards compatible manner. List objects can now be passed back and f…

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 71 matching lines @@
  *     var jsMap = new JsObject.jsify({'a': 1, 'b': 2});
  * 
  * This expression creates a JavaScript array:
  *
  *     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;
+
+// TODO(jacobr): if we care about unchecked mode in Dartium we need to set this
+// to false in unchecked 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 Set<Type> _jsInterfaceTypes = new Set<Type>();
+Iterable<Type> get jsInterfaceTypes => _jsInterfaceTypes.toList();
+
+bool _finalized = false;
+
+class _DeclarationSet {
+  _DeclarationSet() : _methods = <mirrors.MethodMirror>[];
+
+  bool checkType(obj, type) {
+    if (obj == null) return true;
+    return mirrors.reflectType(obj.runtimeType).isSubtypeOf(type);
+  }
+
+  bool checkReturnType(value) {
+    if (value == null) return true;
+    var valueMirror = mirrors.reflectType(value.runtimeType);
+    for (var method in _methods) {
+      if (method.isGetter) {
+        // FIXME: actually check return types for getters that return function
+        // types.
+        return true;
+      } else {
+        if (valueMirror.isSubtypeOf(method.returnType)) return true;
+      }
+    }
+    return false;
+  }
+
+  bool _checkDeclaration(Invocation invocation, mirrors.MethodMirror method) {
+    if (method.isGetter) {
+      // FIXME: actually check method types against the function type returned
+      // by the getter.
+      return true;
+    }
+    var parameters = method.parameters;
+    var positionalArguments = invocation.positionalArguments;
+    // Too many arguments
+    if (parameters.length < positionalArguments.length) return false;
+    // Too few required arguments.
+    if (parameters.length > positionalArguments.length &&
+        !parameters[positionalArguments.length].isOptional) return false;
+    var endPositional = math.min(parameters.length, positionalArguments.length);
+    for (var i = 0; i < endPositional; i++) {
+      if (parameters[i].isNamed) {
+        // Not enough positional arguments.
+        return false;
+      }
+      if (!checkType(invocation.positionalArguments[i], parameters[i].type))
+        return false;
+    }
+    if (invocation.namedArguments.isNotEmpty) {
+      var startPositional;
+      for (startPositional = parameters.length -1 ; startPositional >= 0; startPositional--) {
+        if (!parameters[startPositional].isNamed) break;
+      }
+      startPositional++;
+
+      for (var name in invocation.namedArguments.keys) {
+        bool match = false;
+        for (var j = startPositional; j < parameters.length; j++) {
+          var p = parameters[j];
+          if (p.simpleName == name) {
+            if (!checkType(invocation.namedArguments[name], parameters[j].type))
+              return false;
+            match = true;
+            break;
+          }
+        }
+        if (match == false)
+          return false;
+      }
+
+    }
+    return true;
+  }
+
+  bool checkInvocation(Invocation invocation) {
+    for (var method in _methods) {
+      if (_checkDeclaration(invocation, method)) return true;
+    }
+    return false;
+  }
+
+  void add(mirrors.MethodMirror mirror) {
+    _methods.add(mirror);
+  }
+
+  final List<mirrors.MethodMirror> _methods;
+}
+
+/**
+ * Temporary method that we hope to remove at some point. Should only be called by codegen.
+ */
+void registerJsInterfaces(List<Type> classes) {
+  if (_finalized == true) {
+    throw 'JSInterop class registration already finalized';
+  }
+  Map<Symbol, List<mirrors.DeclarationMirror>> allMembers;
+  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.isStatic) {
+        if (declaration.isGetter) {
+          _allowedGetters.putIfAbsent(symbol, () => new _DeclarationSet()).add(declaration);
+          _allowedMethods.putIfAbsent(symbol, () => new _DeclarationSet()).add(declaration);
+        } else if (declaration.isSetter) {
+          _allowedSetters.putIfAbsent(symbol, () => new _DeclarationSet()).add(declaration);
+        } else if (!declaration.isConstructor) {
+          _allowedMethods.putIfAbsent(symbol, () => new _DeclarationSet()).add(declaration);
+        }
+      }
+    });
+  }
+}
+
+_finalizeJsInterfaces() native "Js_finalizeJsInterfaces";
+
+/**
+ * Generates a part file defining source code for JsObjectImpl and related
+ * classes. This is needed so that type checks for all registered JavaScript
+ * interop classes pass.
+ */
+String _generateJsObjectImplPart() {
+  Iterable<Type> types = jsInterfaceTypes;
+  var libraryPrefixes = new Map<mirrors.LibraryMirror, String>();
+  var prefixNames = new Set<String>();
+  var sb = new StringBuffer();
+
+  var implements = <String>[];
+  for (var type in types) {
+    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('${prefixName}.${mirrors.MirrorSystem.getName(typeMirror.simpleName)}');
+  }
+  libraryPrefixes.forEach((libraryMirror, prefix) {
+    sb.writeln('import "${libraryMirror.uri}" as $prefix;');
+  });
+  var implementsClause = implements.isEmpty ? "" :  "implements ${implements.join(', ')}";
+  // TODO(jacobr): only certain classes need to be implemented by
+  // Function and Array.
+  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 {
+  JsArrayImpl.internal() : super.internal();
+}
+''');
+  return sb.toString();
+}
+
+// Start of block of helper methods to emulate JavaScript Array methods on Dart List.
+// TODO(jacobr): match JS more closely.
+String _toStringJs(obj) => '$obj';
+
+// TODO(jacobr): this might not exactly match JS semantics.
+int _toIntJs(obj) {
+  if (obj is int) return obj;
+  if (obj is num) return obj.toInt();
+  return num.parse('$obj'.trim(), (_) => 0).toInt();
+}
+
+// Helper to match the behavior of setting List length in JavaScript.
+int _setListLength(List list, int len) {
+  for (var i = list.length; i < len; i++) {
+    list.add(null);
+  }
+  return len;
+}
+
+// TODO(jacobr): should we really bother with this method instead of just
+// shallow copying to a JS array and using the join method?
+String _arrayJoin(List list, sep) {
+  if (sep == null) {
+    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, e) {
+  list.add(e);
+  return list.length;
+}
+
+_arrayPop(List list) => list.removeLast();
+
+// TODO(jacobr): would it be better to just copy input to a JS List
+// and call Array.concat?
+List _arrayConcat(List input, List args) {
+  var ret = new List.from(input);
+  for (var e in args) {
+    // TODO(jacobr): should we use Iterable ?
+    if (e is List) { // FIXME use Symbol.isConcatSpreadable
+      ret.addAll(e);
+    } else {
+      ret.add(e);
+    }
+  }
+  return ret;
+}
+
+List _arraySplice(List input, List args) {
+  int start = 0;
+  if (args.length > 0) {
+    var rawStart = _toIntJs(args[0]);
+    if (rawStart < 0) {
+      start = math.max(0, input.length - rawStart);
+    } else {
+      start = math.min(input.length, rawStart);
+    }
+  }
+  var end = start;
+  if (args.length > 1) {
+    var rawDeleteCount = _toIntJs(args[1]);
+    if (rawDeleteCount < 0) rawDeleteCount = 0;
+    end = math.min(input.length, start + rawDeleteCount);
+  }
+  var replacement = [];
+  var removedElements = input.getRange(start, end).toList();
+  if (args.length > 2) {
+    replacement = args.getRange(2, args.length);
+  }
+  input.replaceRange(start, end, replacement);
+  return removedElements;
+}
+
+List _arrayReverse(List l) {
+  for (var i = 0, j = l.length - 1; i < j; i++, j--) {
+    var tmp = l[i];
+    l[i] = l[j];
+    l[j] = tmp;
+  }
+  return l;
+}
+
+_arrayShift(List l) {
+  if (l.isEmpty) return null; // Really want to return JS undefined.
+  return l.removeAt(0);
+}
+
+int _arrayUnshift(List l, List args) {
+  l.insertAll(0, args);
+  return l.length;
+}
+
+_arrayExtend(List l, int newLength) {
+  for (int i = l.length; i < newLength; i++) {
+    // TODO(jacobr): we'd really like to add undefined to better match
+    // JavaScript semantics.
+    l.add(null);
+  }
+}
+
+List _arraySort(List l, rawCompare) {
+  // TODO(jacobr): alternately we could just copy the Array to JavaScript,
+  // invoke the JS sort method and then copy the result back to Dart.
+  Comparator compare;
+  if (rawCompare == null) {
+    compare = (a, b) => _toStringJs(a).compareTo(_toStringJs(b));
+  } else if (rawCompare is JsFunction) {
+    compare = (a, b) => rawCompare.apply([a, b]);
+  } else {
+    compare = rawCompare;
+  }
+  l.sort(compare);
+  return l;
+}
+// End of block of helper methods to emulate JavaScript Array methods on Dart List.
+
+/**
+ * Must be called before JS Interfaces can be used safely used and cross cast.
+ */
+void finalizeJsInterfaces() {
+  if (_finalized == true) {
+    throw 'JSInterop class registration already finalized';
+  }
+  _finalized = true;
+  _finalizeJsInterfaces();
+}
 
 JsObject _cachedContext;
 
 JsObject get _context native "Js_context_Callback";
 
 JsObject get context {
   if (_cachedContext == null) {
     _cachedContext = _context;
   }
   return _cachedContext;
 }
 
 /**
  * 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();
 
   /**
    * Constructs a new JavaScript object from [constructor] and returns a proxy
    * to it.
    */
   factory JsObject(JsFunction constructor, [List arguments]) => _create(constructor, arguments);
 
   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()..add(new JsObject.jsify(varArgs));
+    }
+  }
+
   /**
    * Constructs a [JsObject] that proxies a native Dart object; _for expert use
    * only_.
    *
    * 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`.
@@ skipping 94 matching lines @@
       return _callMethod(method, args);
     } catch(e) {
       if (hasProperty(method)) {
         rethrow;
       } else {
         throw new NoSuchMethodError(this, new Symbol(method), args, null);
       }
     }
   }
 
+  noSuchMethod(Invocation invocation) {
+    throwError() {
+      throw new NoSuchMethodError(this, invocation.memberName, invocation.positionalArguments, invocation.namedArguments);
+    }
+
+    String name = mirrors.MirrorSystem.getName(invocation.memberName);
+    if (invocation.isGetter) {
+      if (_CHECK_JS_INVOCATIONS ) {
+        var matches = _allowedGetters[invocation.memberName];
+        if (matches == null && !_allowedMethods.containsKey(invocation.memberName)) {
+          throwError();
+        }
+        var ret = this[name];
+        if (matches != null && matches.checkReturnType(ret)) return ret;
+        if (ret is Function || (ret is JsFunction /* shouldn't be needed in the future*/) && _allowedMethods.containsKey(invocation.memberName))
+          return ret; // Warning: we have not bound "this"... we could type check on the Function but that is of little value in Dart.
+        throwError();
+      } else {
+        // TODO(jacobr): should we throw if the JavaScript object doesn't have the property?
+        return this[name];
+      }
+    } else if (invocation.isSetter) {
+      if (_CHECK_JS_INVOCATIONS ) {
+        var matches = _allowedSetters[invocation.memberName];
+        if (!matches.checkInvocation(invocation)) throwError();
+      }
+      return this[name] = invocation.positionalArguments.first;
+    } else {
+      // TODO(jacobr): also allow calling getters that look like functions.
+      var matches;
+      if (_CHECK_JS_INVOCATIONS ) {
+        matches = _allowedMethods[invocation.memberName];
+        if (matches == null || !matches.checkInvocation(invocation)) throwError();
+      }
+      var ret = this.callMethod(name, _buildArgs(invocation));
+      if (_CHECK_JS_INVOCATIONS ) {
+        if (!matches.checkReturnType(ret)) throwError();
+      }
+      return ret;
+    }
+  }
+
   _callMethod(String name, List args) native "JsObject_callMethod";
 }
 
 /**
  * Proxies a JavaScript Function object.
  */
-class JsFunction extends JsObject {
+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";
 
+  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";
 
   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";
 
   _checkIndex(int index, {bool insert: false}) {
@@ skipping 92 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]));