Support user generated custom native JS classes.

sdk/lib/_internal/js_runtime/lib/interceptors.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.
 
 library _interceptors;
 
 import 'dart:_js_embedded_names' show
     DISPATCH_PROPERTY_NAME,
     TYPE_TO_INTERCEPTOR_MAP;
 
 import 'dart:collection';
 import 'dart:_internal' hide Symbol;
 import "dart:_internal" as _symbol_dev show Symbol;
 import 'dart:_js_helper' show allMatchesInStringUnchecked,
                               Null,
                               JSSyntaxRegExp,
                               Primitives,
                               argumentErrorValue,
                               checkInt,
                               checkNull,
                               checkNum,
                               checkString,
                               defineProperty,
                               diagnoseIndexError,
+                              getIsolateAffinityTag,
                               getRuntimeType,
                               initNativeDispatch,
                               initNativeDispatchFlag,
                               regExpGetNative,
                               regExpCaptureCount,
                               stringContainsUnchecked,
                               stringIndexOfStringUnchecked,
                               stringLastIndexOfUnchecked,
                               stringReplaceAllFuncUnchecked,
                               stringReplaceAllUnchecked,
                               stringReplaceFirstUnchecked,
                               stringReplaceFirstMappedUnchecked,
                               stringReplaceRangeUnchecked,
                               lookupAndCacheInterceptor,
                               lookupDispatchRecord,
                               StringMatch,
                               firstMatchAfter,
                               NoInline;
+import 'dart:js' show JsNative;
+
 import 'dart:_foreign_helper' show
     JS,
     JS_EFFECT,
     JS_EMBEDDED_GLOBAL,
     JS_INTERCEPTOR_CONSTANT,
     JS_STRING_CONCAT;
 import 'dart:math' show Random;
 
 part 'js_array.dart';
 part 'js_number.dart';
 part 'js_string.dart';
 
+final String DART_CLOSURE_PROPERTY_NAME =
+    getIsolateAffinityTag(r'_$dart_dartClosure');
+
 String _symbolToString(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 _symbolMapToStringMap(Map<Symbol, dynamic> map) {
   if (map == null) return null;
   var result = new Map<String, dynamic>();
   map.forEach((Symbol key, value) {
     result[_symbolToString(key)] = value;
   });
   return result;
 }
@@ skipping 98 matching lines @@
       throw new UnimplementedError('Return interceptor for $discriminatedTag');
     }
   }
 
   var interceptor = lookupAndCacheInterceptor(object);
   if (interceptor == null) {
     // JavaScript Objects created via object literals and `Object.create(null)`
     // are 'plain' Objects.  This test could be simplified and the dispatch path
     // be faster if Object.prototype was pre-patched with a non-leaf dispatch
     // record.
+    if (JS('bool', 'typeof # == "function"', object)) {
+      return JS_INTERCEPTOR_CONSTANT(JavaScriptFunction);
+    }
     var proto = JS('', 'Object.getPrototypeOf(#)', object);
     if (JS('bool', '# == null || # === Object.prototype', proto, proto)) {
       return JS_INTERCEPTOR_CONSTANT(PlainJavaScriptObject);
     } else {
       return JS_INTERCEPTOR_CONSTANT(UnknownJavaScriptObject);
     }
   }
 
   return interceptor;
 }
@@ skipping 204 matching lines @@
  * This is the type that should be exported by a JavaScript interop library.
  */
 abstract class JSObject {
 }
 
 
 /**
  * Interceptor base class for JavaScript objects not recognized as some more
  * specific native type.
  */
-abstract class JavaScriptObject extends Interceptor implements JSObject {
+class JavaScriptObject extends Interceptor implements JSObject {
   const JavaScriptObject();
 
   // It would be impolite to stash a property on the object.
   int get hashCode => 0;
 
   Type get runtimeType => JSObject;
+
+  /**
+   * Returns the result of the JavaScript objects `toString` method.
+   */
+  String toString() {
+    try {
+      return JS('String', 'String(#)', this);
+    } catch(e) {
+      return super.toString();
+    }
+  }
 }
 
 
 /**
  * Interceptor for plain JavaScript objects created as JavaScript object
  * literals or `new Object()`.
  */
 class PlainJavaScriptObject extends JavaScriptObject {
   const PlainJavaScriptObject();
 }
 
 
 /**
  * Interceptor for unclassified JavaScript objects, typically objects with a
  * non-trivial prototype chain.
  *
  * This class also serves as a fallback for unknown JavaScript exceptions.
  */
 class UnknownJavaScriptObject extends JavaScriptObject {
   const UnknownJavaScriptObject();
 
   String toString() => JS('String', 'String(#)', this);
 }
+
+/**
+ * Interceptor for JavaScript function objects and Dart functions that have
+ * been converted to JavaScript functions.
+ * These interceptor methods are not always used as the JavaScript function
+ * object has also been mangled to support Dart function calling conventions.
+ */
+class JavaScriptFunction extends JavaScriptObject implements Function {
+  const JavaScriptFunction();
+
+  String toString() { 
+    var dartClosure = JsNative.getProperty(this, DART_CLOSURE_PROPERTY_NAME);
+    return dartClosure == null ? super.toString() : dartClosure.toString();
+  }
+}