Remove JSClosure.callAsFunction

Author: kateinoigakukun

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -183,12 +183,14 @@ try test("Function Call") {
     try expectEqual(func6(true, "OK", 2), .string("OK"))
 }
 
+let evalClosure = JSObject.global.globalObject1.eval_closure.function!
+
 try test("Closure Lifetime") {
     do {
         let c1 = JSClosure { arguments in
             return arguments[0]
         }
-        try expectEqual(c1(arguments: [JSValue.number(1.0)]), .number(1.0))
+        try expectEqual(evalClosure(c1, JSValue.number(1.0)), .number(1.0))
         c1.release()
     }
 
@@ -198,7 +200,7 @@ try test("Closure Lifetime") {
         }
         c1.release()
         // Call a released closure
-        _ = try expectThrow(try c1.throws())
+        _ = try expectThrow(try evalClosure.throws(c1))
     }
 
     do {
@@ -207,17 +209,17 @@ try test("Closure Lifetime") {
             _ = JSClosure { _ in .undefined }
             return .undefined
         }
-        _ = try expectThrow(try c1.throws())
+        _ = try expectThrow(try evalClosure.throws(c1))
         c1.release()
     }
 
     do {
         let c1 = JSOneshotClosure { _ in
             return .boolean(true)
         }
-        try expectEqual(c1(), .boolean(true))
+        try expectEqual(evalClosure(c1), .boolean(true))
         // second call will cause `fatalError` that can be caught as a JavaScript exception
-        _ = try expectThrow(try c1.throws())
+        _ = try expectThrow(try evalClosure.throws(c1))
         // OneshotClosure won't call fatalError even if it's deallocated before `release`
     }
 }
@@ -244,7 +246,7 @@ try test("Host Function Registration") {
         return .number(1)
     }
 
-    setJSValue(this: prop_6Ref, name: "host_func_1", value: .function(hostFunc1))
+    setJSValue(this: prop_6Ref, name: "host_func_1", value: .object(hostFunc1))
 
     let call_host_1 = getJSValue(this: prop_6Ref, name: "call_host_1")
     let call_host_1Func = try expectFunction(call_host_1)
@@ -262,8 +264,8 @@ try test("Host Function Registration") {
         }
     }
 
-    try expectEqual(hostFunc2(3), .number(6))
-    _ = try expectString(hostFunc2(true))
+    try expectEqual(evalClosure(hostFunc2, 3), .number(6))
+    _ = try expectString(evalClosure(hostFunc2, true))
     hostFunc2.release()
 }
 
@@ -375,7 +377,7 @@ try test("ObjectRef Lifetime") {
 
     let identity = JSClosure { $0[0] }
     let ref1 = getJSValue(this: .global, name: "globalObject1").object!
-    let ref2 = identity(ref1).object!
+    let ref2 = evalClosure(identity, ref1).object!
     try expectEqual(ref1.prop_2, .number(2))
     try expectEqual(ref2.prop_2, .number(2))
     identity.release()

IntegrationTests/bin/primary-tests.js

@@ -47,6 +47,9 @@ global.globalObject1 = {
             throw 3.0
         },
     },
+    eval_closure: function(fn) {
+        return fn(arguments[1])
+    }
 };
 
 global.Animal = function (name, age, isCat) {

Sources/JavaScriptKit/BasicObjects/JSTimer.swift

@@ -1,68 +1,68 @@
 /** This timer is an abstraction over [`setInterval`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setInterval)
-/ [`clearInterval`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/clearInterval) and 
+/ [`clearInterval`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/clearInterval) and
 [`setTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout)
 / [`clearTimeout`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout)
 JavaScript functions. It intentionally doesn't match the JavaScript API, as a special care is
 needed to hold a reference to the timer closure and to call `JSClosure.release()` on it when the
 timer is deallocated. As a user, you have to hold a reference to a `JSTimer` instance for it to stay
 valid. The `JSTimer` API is also intentionally trivial, the timer is started right away, and the
 only way to invalidate the timer is to bring the reference count of the `JSTimer` instance to zero.
-For invalidation you should either store the timer in an optional property and assign `nil` to it, 
+For invalidation you should either store the timer in an optional property and assign `nil` to it,
 or deallocate the object that owns the timer.
 */
 public final class JSTimer {
-  /// Indicates whether this timer instance calls its callback repeatedly at a given delay.
-  public let isRepeating: Bool
+    /// Indicates whether this timer instance calls its callback repeatedly at a given delay.
+    public let isRepeating: Bool
 
-  private let closure: JSOneshotClosure
+    private let closure: JSClosureProtocol
 
-  /** Node.js and browser APIs are slightly different. `setTimeout`/`setInterval` return an object
-  in Node.js, while browsers return a number. Fortunately, clearTimeout and clearInterval take
-  corresponding types as their arguments, and we can store either as JSValue, so we can treat both
-  cases uniformly.
-  */
-  private let value: JSValue
-  private let global = JSObject.global
+    /** Node.js and browser APIs are slightly different. `setTimeout`/`setInterval` return an object
+     in Node.js, while browsers return a number. Fortunately, clearTimeout and clearInterval take
+     corresponding types as their arguments, and we can store either as JSValue, so we can treat both
+     cases uniformly.
+     */
+    private let value: JSValue
+    private let global = JSObject.global
 
-  /**
-  Creates a new timer instance that calls `setInterval` or `setTimeout` JavaScript functions for you
-  under the hood.
-  - Parameters:
-    - millisecondsDelay: the amount of milliseconds before the `callback` closure is executed.
-    - isRepeating: when `true` the `callback` closure is executed repeatedly at given 
-    `millisecondsDelay` intervals indefinitely until the timer is deallocated.
-    - callback: the closure to be executed after a given `millisecondsDelay` interval.
-  */
-  public init(millisecondsDelay: Double, isRepeating: Bool = false, callback: @escaping () -> ()) {
-    if isRepeating {
-        closure = JSClosure { _ in
-            callback()
-            return .undefined
+    /**
+     Creates a new timer instance that calls `setInterval` or `setTimeout` JavaScript functions for you
+     under the hood.
+     - Parameters:
+     - millisecondsDelay: the amount of milliseconds before the `callback` closure is executed.
+     - isRepeating: when `true` the `callback` closure is executed repeatedly at given
+     `millisecondsDelay` intervals indefinitely until the timer is deallocated.
+     - callback: the closure to be executed after a given `millisecondsDelay` interval.
+     */
+    public init(millisecondsDelay: Double, isRepeating: Bool = false, callback: @escaping () -> ()) {
+        if isRepeating {
+            closure = JSClosure { _ in
+                callback()
+                return .undefined
+            }
+        } else {
+            closure = JSOneshotClosure { _ in
+                callback()
+                return .undefined
+            }
         }
-    } else {
-        closure = JSOneshotClosure { _ in
-            callback()
-            return .undefined
+        self.isRepeating = isRepeating
+        if isRepeating {
+            value = global.setInterval.function!(closure, millisecondsDelay)
+        } else {
+            value = global.setTimeout.function!(closure, millisecondsDelay)
         }
     }
-    self.isRepeating = isRepeating
-    if isRepeating {
-      value = global.setInterval.function!(closure, millisecondsDelay)
-    } else {
-      value = global.setTimeout.function!(closure, millisecondsDelay)
-    }
-  }
 
-  /** Makes a corresponding `clearTimeout` or `clearInterval` call, depending on whether this timer
-  instance is repeating. The `closure` instance is released manually here, as it is required for
-  bridged closure instances.
-  */
-  deinit {
-    if isRepeating {
-      global.clearInterval.function!(value)
-    } else {
-      global.clearTimeout.function!(value)
+    /** Makes a corresponding `clearTimeout` or `clearInterval` call, depending on whether this timer
+     instance is repeating. The `closure` instance is released manually here, as it is required for
+     bridged closure instances.
+     */
+    deinit {
+        if isRepeating {
+            global.clearInterval.function!(value)
+        } else {
+            global.clearTimeout.function!(value)
+        }
+        closure.release()
     }
-    closure.release()
-  }
 }

Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift

@@ -1,9 +1,17 @@
 import _CJavaScriptKit
 
-fileprivate var sharedFunctions: [JavaScriptHostFuncRef: ([JSValue]) -> JSValue] = [:]
+fileprivate var sharedClosures: [JavaScriptHostFuncRef: ([JSValue]) -> JSValue] = [:]
+
+/// JSClosureProtocol abstracts closure object in JavaScript, whose lifetime is manualy managed
+public protocol JSClosureProtocol: JSValueCompatible {
+
+    /// Release this function resource.
+    /// After calling `release`, calling this function from JavaScript will fail.
+    func release()
+}
 
 /// `JSOneshotClosure` is a JavaScript function that can be called only once.
-public class JSOneshotClosure: JSFunction {
+public class JSOneshotClosure: JSObject, JSClosureProtocol {
     private var hostFuncRef: JavaScriptHostFuncRef = 0
 
     public init(_ body: @escaping ([JSValue]) -> JSValue) {
@@ -12,7 +20,10 @@ public class JSOneshotClosure: JSFunction {
         let objectId = ObjectIdentifier(self)
         let funcRef = JavaScriptHostFuncRef(bitPattern: Int32(objectId.hashValue))
         // 2. Retain the given body in static storage by `funcRef`.
-        sharedFunctions[funcRef] = body
+        sharedClosures[funcRef] = {
+            defer { self.release() }
+            return body($0)
+        }
         // 3. Create a new JavaScript function which calls the given Swift function.
         var objectRef: JavaScriptObjectRef = 0
         _create_function(funcRef, &objectRef)
@@ -21,15 +32,10 @@ public class JSOneshotClosure: JSFunction {
         id = objectRef
     }
 
-    public override func callAsFunction(this: JSObject? = nil, arguments: [ConvertibleToJSValue]) -> JSValue {
-        defer { release() }
-        return super.callAsFunction(this: this, arguments: arguments)
-    }
-
     /// Release this function resource.
     /// After calling `release`, calling this function from JavaScript will fail.
     public func release() {
-        sharedFunctions[hostFuncRef] = nil
+        sharedClosures[hostFuncRef] = nil
     }
 }
 
@@ -52,30 +58,37 @@ public class JSOneshotClosure: JSFunction {
 /// eventListenter.release()
 /// ```
 ///
-public class JSClosure: JSOneshotClosure {
-    
+public class JSClosure: JSObject, JSClosureProtocol {
+    private var hostFuncRef: JavaScriptHostFuncRef = 0
     var isReleased: Bool = false
 
     @available(*, deprecated, message: "This initializer will be removed in the next minor version update. Please use `init(_ body: @escaping ([JSValue]) -> JSValue)` and add `return .undefined` to the end of your closure")
     @_disfavoredOverload
-    public init(_ body: @escaping ([JSValue]) -> ()) {
-        super.init({
+    public convenience init(_ body: @escaping ([JSValue]) -> ()) {
+        self.init({
             body($0)
             return .undefined
         })
     }
 
-    public override init(_ body: @escaping ([JSValue]) -> JSValue) {
-        super.init(body)
-    }
+    public init(_ body: @escaping ([JSValue]) -> JSValue) {
+        // 1. Fill `id` as zero at first to access `self` to get `ObjectIdentifier`.
+        super.init(id: 0)
+        let objectId = ObjectIdentifier(self)
+        let funcRef = JavaScriptHostFuncRef(bitPattern: Int32(objectId.hashValue))
+        // 2. Retain the given body in static storage by `funcRef`.
+        sharedClosures[funcRef] = body
+        // 3. Create a new JavaScript function which calls the given Swift function.
+        var objectRef: JavaScriptObjectRef = 0
+        _create_function(funcRef, &objectRef)
 
-    public override func callAsFunction(this: JSObject? = nil, arguments: [ConvertibleToJSValue]) -> JSValue {
-        try! invokeJSFunction(self, arguments: arguments, this: this)
+        hostFuncRef = funcRef
+        id = objectRef
     }
-    
-    public override func release() {
+
+    public func release() {
         isReleased = true
-        super.release()
+        sharedClosures[hostFuncRef] = nil
     }
 
     deinit {
@@ -126,7 +139,7 @@ func _call_host_function_impl(
     _ argv: UnsafePointer<RawJSValue>, _ argc: Int32,
     _ callbackFuncRef: JavaScriptObjectRef
 ) {
-    guard let hostFunc = sharedFunctions[hostFuncRef] else {
+    guard let hostFunc = sharedClosures[hostFuncRef] else {
         fatalError("The function was already released")
     }
     let arguments = UnsafeBufferPointer(start: argv, count: Int(argc)).map {

Sources/JavaScriptKit/JSValue.swift

@@ -142,7 +142,7 @@ extension JSValue {
     /// ```
     @available(*, deprecated, message: "Please create JSClosure directly and manage its lifetime manually.")
     public static func function(_ body: @escaping ([JSValue]) -> JSValue) -> JSValue {
-        .function(JSClosure(body))
+        .object(JSClosure(body))
     }
 }