Unify JSFunction with JSObject

kateinoigakukun · kateinoigakukun · commit 8ef8f6894720 · 2025-09-11T18:14:16.000+09:00
diff --git a/Sources/JavaScriptBigIntSupport/Int64+I64.swift b/Sources/JavaScriptBigIntSupport/Int64+I64.swift
@@ -1,13 +1,13 @@
 import JavaScriptKit
 
 extension UInt64: JavaScriptKit.ConvertibleToJSValue, JavaScriptKit.TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.BigUint64Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.BigUint64Array.object! }
 
     public var jsValue: JSValue { .bigInt(JSBigInt(unsigned: self)) }
 }
 
 extension Int64: JavaScriptKit.ConvertibleToJSValue, JavaScriptKit.TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.BigInt64Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.BigInt64Array.object! }
 
     public var jsValue: JSValue { .bigInt(JSBigInt(self)) }
 }
diff --git a/Sources/JavaScriptKit/BasicObjects/JSArray.swift b/Sources/JavaScriptKit/BasicObjects/JSArray.swift
@@ -2,8 +2,8 @@
 /// class](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)
 /// that exposes its properties in a type-safe and Swifty way.
 public class JSArray: JSBridgedClass {
-    public static var constructor: JSFunction? { _constructor.wrappedValue }
-    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Array.function })
+    public static var constructor: JSObject? { _constructor.wrappedValue }
+    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Array.object })
 
     static func isArray(_ object: JSObject) -> Bool {
         constructor!.isArray!(object).boolean!
diff --git a/Sources/JavaScriptKit/BasicObjects/JSDate.swift b/Sources/JavaScriptKit/BasicObjects/JSDate.swift
@@ -7,8 +7,8 @@
 /// property if you need those.
 public final class JSDate: JSBridgedClass {
     /// The constructor function used to create new `Date` objects.
-    public static var constructor: JSFunction? { _constructor.wrappedValue }
-    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Date.function })
+    public static var constructor: JSObject? { _constructor.wrappedValue }
+    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Date.object })
 
     /// The underlying JavaScript `Date` object.
     public let jsObject: JSObject
diff --git a/Sources/JavaScriptKit/BasicObjects/JSError.swift b/Sources/JavaScriptKit/BasicObjects/JSError.swift
@@ -3,8 +3,8 @@
 /// exposes its properties in a type-safe way.
 public final class JSError: JSBridgedClass {
     /// The constructor function used to create new JavaScript `Error` objects.
-    public static var constructor: JSFunction? { _constructor.wrappedValue }
-    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Error.function })
+    public static var constructor: JSObject? { _constructor.wrappedValue }
+    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Error.object })
 
     /// The underlying JavaScript `Error` object.
     public let jsObject: JSObject
diff --git a/Sources/JavaScriptKit/BasicObjects/JSPromise.swift b/Sources/JavaScriptKit/BasicObjects/JSPromise.swift
@@ -12,8 +12,8 @@ public final class JSPromise: JSBridgedClass {
         .object(jsObject)
     }
 
-    public static var constructor: JSFunction? {
-        JSObject.global.Promise.function!
+    public static var constructor: JSObject? {
+        JSObject.global.Promise.object!
     }
 
     /// This private initializer assumes that the passed object is a JavaScript `Promise`
@@ -54,8 +54,8 @@ public final class JSPromise: JSBridgedClass {
         let closure = JSOneshotClosure { arguments in
             // The arguments are always coming from the `Promise` constructor, so we should be
             // safe to assume their type here
-            let resolve = arguments[0].function!
-            let reject = arguments[1].function!
+            let resolve = arguments[0].object!
+            let reject = arguments[1].object!
 
             resolver {
                 switch $0 {
diff --git a/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift b/Sources/JavaScriptKit/BasicObjects/JSTypedArray.swift
@@ -7,15 +7,15 @@ import _CJavaScriptKit
 public protocol TypedArrayElement {
     associatedtype Element: ConvertibleToJSValue, ConstructibleFromJSValue = Self
     /// The constructor function for the TypedArray class for this particular kind of number
-    static var typedArrayClass: JSFunction { get }
+    static var typedArrayClass: JSObject { get }
 }
 
 /// A wrapper around all [JavaScript `TypedArray`
 /// classes](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/TypedArray)
 /// that exposes their properties in a type-safe way.
 public final class JSTypedArray<Traits>: JSBridgedClass, ExpressibleByArrayLiteral where Traits: TypedArrayElement {
     public typealias Element = Traits.Element
-    public class var constructor: JSFunction? { Traits.typedArrayClass }
+    public class var constructor: JSObject? { Traits.typedArrayClass }
     public var jsObject: JSObject
 
     public subscript(_ index: Int) -> Element {
@@ -141,64 +141,64 @@ public final class JSTypedArray<Traits>: JSBridgedClass, ExpressibleByArrayLiter
 }
 
 extension Int: TypedArrayElement {
-    public static var typedArrayClass: JSFunction {
+    public static var typedArrayClass: JSObject {
         #if _pointerBitWidth(_32)
-        return JSObject.global.Int32Array.function!
+        return JSObject.global.Int32Array.object!
         #elseif _pointerBitWidth(_64)
-        return JSObject.global.Int64Array.function!
+        return JSObject.global.Int64Array.object!
         #else
         #error("Unsupported pointer width")
         #endif
     }
 }
 
 extension UInt: TypedArrayElement {
-    public static var typedArrayClass: JSFunction {
+    public static var typedArrayClass: JSObject {
         #if _pointerBitWidth(_32)
-        return JSObject.global.Uint32Array.function!
+        return JSObject.global.Uint32Array.object!
         #elseif _pointerBitWidth(_64)
-        return JSObject.global.Uint64Array.function!
+        return JSObject.global.Uint64Array.object!
         #else
         #error("Unsupported pointer width")
         #endif
     }
 }
 
 extension Int8: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Int8Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Int8Array.object! }
 }
 
 extension UInt8: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Uint8Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Uint8Array.object! }
 }
 
 extension Int16: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Int16Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Int16Array.object! }
 }
 
 extension UInt16: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Uint16Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Uint16Array.object! }
 }
 
 extension Int32: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Int32Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Int32Array.object! }
 }
 
 extension UInt32: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Uint32Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Uint32Array.object! }
 }
 
 extension Float32: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Float32Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Float32Array.object! }
 }
 
 extension Float64: TypedArrayElement {
-    public static var typedArrayClass: JSFunction { JSObject.global.Float64Array.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Float64Array.object! }
 }
 
 public enum JSUInt8Clamped: TypedArrayElement {
     public typealias Element = UInt8
-    public static var typedArrayClass: JSFunction { JSObject.global.Uint8ClampedArray.function! }
+    public static var typedArrayClass: JSObject { JSObject.global.Uint8ClampedArray.object! }
 }
 
 public typealias JSUInt8ClampedArray = JSTypedArray<JSUInt8Clamped>
diff --git a/Sources/JavaScriptKit/ConvertibleToJSValue.swift b/Sources/JavaScriptKit/ConvertibleToJSValue.swift
@@ -79,15 +79,12 @@ extension JSString: ConvertibleToJSValue {
     public var jsValue: JSValue { .string(self) }
 }
 
-extension JSObject: JSValueCompatible {
-    // `JSObject.jsValue` is defined in JSObject.swift to be able to overridden
-    // from `JSFunction`
-}
+extension JSObject: JSValueCompatible {}
 
-private let _objectConstructor = LazyThreadLocal(initialize: { JSObject.global.Object.function! })
-private var objectConstructor: JSFunction { _objectConstructor.wrappedValue }
-private let _arrayConstructor = LazyThreadLocal(initialize: { JSObject.global.Array.function! })
-private var arrayConstructor: JSFunction { _arrayConstructor.wrappedValue }
+private let _objectConstructor = LazyThreadLocal(initialize: { JSObject.global.Object.object! })
+private var objectConstructor: JSObject { _objectConstructor.wrappedValue }
+private let _arrayConstructor = LazyThreadLocal(initialize: { JSObject.global.Array.object! })
+private var arrayConstructor: JSObject { _arrayConstructor.wrappedValue }
 
 #if !hasFeature(Embedded)
 extension Dictionary where Value == ConvertibleToJSValue, Key == String {
@@ -177,7 +174,7 @@ extension Array: ConstructibleFromJSValue where Element: ConstructibleFromJSValu
     public static func construct(from value: JSValue) -> [Element]? {
         guard
             let objectRef = value.object,
-            objectRef.isInstanceOf(JSObject.global.Array.function!)
+            objectRef.isInstanceOf(JSObject.global.Array.object!)
         else { return nil }
 
         let count: Int = objectRef.length.fromJSValue()!
@@ -208,8 +205,6 @@ extension RawJSValue: ConvertibleToJSValue {
             return .null
         case .undefined:
             return .undefined
-        case .function:
-            return .function(JSFunction(id: UInt32(payload1)))
         case .symbol:
             return .symbol(JSSymbol(id: UInt32(payload1)))
         case .bigInt:
@@ -248,9 +243,6 @@ extension JSValue {
         case .undefined:
             kind = .undefined
             payload1 = 0
-        case .function(let functionRef):
-            kind = .function
-            payload1 = JavaScriptPayload1(functionRef.id)
         case .symbol(let symbolRef):
             kind = .symbol
             payload1 = JavaScriptPayload1(symbolRef.id)
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSBigInt.swift b/Sources/JavaScriptKit/FundamentalObjects/JSBigInt.swift
@@ -1,6 +1,6 @@
 import _CJavaScriptKit
 
-private var constructor: JSFunction { JSObject.global.BigInt.function! }
+private var constructor: JSObject { JSObject.global.BigInt.object! }
 
 /// A wrapper around [the JavaScript `BigInt`
 /// class](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift b/Sources/JavaScriptKit/FundamentalObjects/JSClosure.swift
@@ -103,7 +103,7 @@ public class JSOneshotClosure: JSObject, JSClosureProtocol {
 /// button.removeEventListener!("click", JSValue.function(eventListener))
 /// ```
 ///
-public class JSClosure: JSFunction, JSClosureProtocol {
+public class JSClosure: JSObject, JSClosureProtocol {
 
     class SharedJSClosure {
         // Note: 6.0 compilers built with assertions enabled crash when calling
@@ -317,7 +317,7 @@ func _call_host_function_impl(
         arguments.append(argv[i].jsValue)
     }
     let result = hostFunc(arguments)
-    let callbackFuncRef = JSFunction(id: callbackFuncRef)
+    let callbackFuncRef = JSObject(id: callbackFuncRef)
     _ = callbackFuncRef(result)
     return false
 }
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSObject+CallAsFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSObject+CallAsFunction.swift
@@ -1,16 +1,14 @@
 import _CJavaScriptKit
 
-/// `JSFunction` represents a function in JavaScript and supports new object instantiation.
-/// This type can be callable as a function using `callAsFunction`.
-///
-/// e.g.
-/// ```swift
-/// let alert: JSFunction = JSObject.global.alert.function!
-/// // Call `JSFunction` as a function
-/// alert("Hello, world")
-/// ```
-///
-public class JSFunction: JSObject {
+@available(
+    *,
+    deprecated,
+    renamed: "JSObject",
+    message: "Please use JSObject instead. JSFunction is unified with JSObject"
+)
+public typealias JSFunction = JSObject
+
+extension JSObject {
     #if !hasFeature(Embedded)
     /// Call this function with given `arguments` and binding given `this` as context.
     /// - Parameters:
@@ -104,10 +102,6 @@ public class JSFunction: JSObject {
         fatalError("unavailable")
     }
 
-    override public var jsValue: JSValue {
-        .function(self)
-    }
-
     final func invokeNonThrowingJSFunction(arguments: [JSValue]) -> RawJSValue {
         arguments.withRawJSValues { invokeNonThrowingJSFunction(rawValues: $0) }
     }
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift b/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
@@ -16,8 +16,8 @@ import _CJavaScriptKit
 /// reference counting system.
 @dynamicMemberLookup
 public class JSObject: Equatable, ExpressibleByDictionaryLiteral {
-    internal static var constructor: JSFunction { _constructor.wrappedValue }
-    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Object.function! })
+    internal static var constructor: JSObject { _constructor.wrappedValue }
+    private static let _constructor = LazyThreadLocal(initialize: { JSObject.global.Object.object! })
 
     @usableFromInline
     internal var _id: JavaScriptObjectRef
@@ -213,7 +213,7 @@ public class JSObject: Equatable, ExpressibleByDictionaryLiteral {
     /// Return `true` if this value is an instance of the passed `constructor` function.
     /// - Parameter constructor: The constructor function to check.
     /// - Returns: The result of `instanceof` in the JavaScript environment.
-    public func isInstanceOf(_ constructor: JSFunction) -> Bool {
+    public func isInstanceOf(_ constructor: JSObject) -> Bool {
         assertOnOwnerThread(hint: "calling 'isInstanceOf'")
         return swjs_instanceof(id, constructor.id)
     }
@@ -258,8 +258,6 @@ public class JSObject: Equatable, ExpressibleByDictionaryLiteral {
             return nil
         case .object(let object):
             return object as? Self
-        case .function(let function):
-            return function as? Self
         case .symbol(let symbol):
             return symbol as? Self
         case .bigInt(let bigInt):
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSSymbol.swift b/Sources/JavaScriptKit/FundamentalObjects/JSSymbol.swift
@@ -1,7 +1,7 @@
 import _CJavaScriptKit
 
-private let _Symbol = LazyThreadLocal(initialize: { JSObject.global.Symbol.function! })
-private var Symbol: JSFunction { _Symbol.wrappedValue }
+private let _Symbol = LazyThreadLocal(initialize: { JSObject.global.Symbol.object! })
+private var Symbol: JSObject { _Symbol.wrappedValue }
 
 /// A wrapper around [the JavaScript `Symbol`
 /// class](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Symbol)
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift
@@ -4,8 +4,8 @@ import _CJavaScriptKit
 /// A `JSFunction` wrapper that enables throwing function calls.
 /// Exceptions produced by JavaScript functions will be thrown as `JSValue`.
 public class JSThrowingFunction {
-    private let base: JSFunction
-    public init(_ base: JSFunction) {
+    private let base: JSObject
+    public init(_ base: JSObject) {
         self.base = base
     }
 
@@ -73,7 +73,7 @@ public class JSThrowingFunction {
 }
 
 private func invokeJSFunction(
-    _ jsFunc: JSFunction,
+    _ jsFunc: JSObject,
     arguments: [ConvertibleToJSValue],
     this: JSObject?
 ) throws -> JSValue {
diff --git a/Sources/JavaScriptKit/JSBridgedType.swift b/Sources/JavaScriptKit/JSBridgedType.swift
@@ -29,7 +29,7 @@ public protocol _JSBridgedClass {
 /// Conform to this protocol when your Swift class wraps a JavaScript class.
 public protocol JSBridgedClass: JSBridgedType, _JSBridgedClass {
     /// The constructor function for the JavaScript class
-    static var constructor: JSFunction? { get }
+    static var constructor: JSObject? { get }
 
     /// The JavaScript object wrapped by this instance.
     /// You may assume that `jsObject instanceof Self.constructor == true`
diff --git a/Sources/JavaScriptKit/JSValue.swift b/Sources/JavaScriptKit/JSValue.swift
diff --git a/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h b/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h
diff --git a/Tests/JavaScriptKitTests/JavaScriptKitTests.swift b/Tests/JavaScriptKitTests/JavaScriptKitTests.swift

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`	`1`	`import JavaScriptKit`
`2`	`2`
`3`	`3`	`extension UInt64: JavaScriptKit.ConvertibleToJSValue, JavaScriptKit.TypedArrayElement {`
`4`		`- public static var typedArrayClass: JSFunction { JSObject.global.BigUint64Array.function! }`
	`4`	`+ public static var typedArrayClass: JSObject { JSObject.global.BigUint64Array.object! }`
`5`	`5`
`6`	`6`	`public var jsValue: JSValue { .bigInt(JSBigInt(unsigned: self)) }`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`extension Int64: JavaScriptKit.ConvertibleToJSValue, JavaScriptKit.TypedArrayElement {`
`10`		`- public static var typedArrayClass: JSFunction { JSObject.global.BigInt64Array.function! }`
	`10`	`+ public static var typedArrayClass: JSObject { JSObject.global.BigInt64Array.object! }`
`11`	`11`
`12`	`12`	`public var jsValue: JSValue { .bigInt(JSBigInt(self)) }`
`13`	`13`	`}`