Re-add support for Symbol objects via JSSymbol (#183)

j-f1 · web-flow · commit 8c20a891db7b · 2022-04-10T13:24:21.000+09:00
* Revert "Revert "Revert "Revert "Add support for Symbol objects via JSSymbol (#179)"""" This reverts commit 85e1a11. * Ignore .vscode * Drop Reflect.get/set in favor of subscript syntax * Also drop Reflect.{apply,construct} * Fix bad test
diff --git a/.gitignore b/.gitignore
@@ -6,3 +6,4 @@ node_modules
 /*.xcodeproj
 xcuserdata/
 .swiftpm
+.vscode
diff --git a/IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift b/IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift
@@ -804,6 +804,32 @@ try test("Hashable Conformance") {
     try expectEqual(firstHash, secondHash)
 }
 
+try test("Symbols") {
+    let symbol1 = JSSymbol("abc")
+    let symbol2 = JSSymbol("abc")
+    try expectNotEqual(symbol1, symbol2)
+    try expectEqual(symbol1.name, symbol2.name)
+    try expectEqual(symbol1.name, "abc")
+
+    try expectEqual(JSSymbol.iterator, JSSymbol.iterator)
+
+    // let hasInstanceClass = {
+    //   prop: function () {}
+    // }.prop
+    // Object.defineProperty(hasInstanceClass, Symbol.hasInstance, { value: () => true })
+    let hasInstanceObject = JSObject.global.Object.function!.new()
+    hasInstanceObject.prop = JSClosure { _ in .undefined }.jsValue
+    let hasInstanceClass = hasInstanceObject.prop.function!
+    let propertyDescriptor = JSObject.global.Object.function!.new()
+    propertyDescriptor.value = JSClosure { _ in .boolean(true) }.jsValue
+    _ = JSObject.global.Object.function!.defineProperty!(
+        hasInstanceClass, JSSymbol.hasInstance,
+        propertyDescriptor
+    )
+    try expectEqual(hasInstanceClass[JSSymbol.hasInstance].function!().boolean, true)
+    try expectEqual(JSObject.global.Object.isInstanceOf(hasInstanceClass), true)
+}
+
 struct AnimalStruct: Decodable {
     let name: String
     let age: Int
diff --git a/Runtime/src/index.ts b/Runtime/src/index.ts
@@ -110,11 +110,9 @@ export class SwiftRuntime {
             payload2: number
         ) => {
             const obj = this.memory.getObject(ref);
-            Reflect.set(
-                obj,
-                this.memory.getObject(name),
-                JSValue.decode(kind, payload1, payload2, this.memory)
-            );
+            const key = this.memory.getObject(name);
+            const value = JSValue.decode(kind, payload1, payload2, this.memory);
+            obj[key] = value;
         },
 
         swjs_get_prop: (
@@ -125,7 +123,8 @@ export class SwiftRuntime {
             payload2_ptr: pointer
         ) => {
             const obj = this.memory.getObject(ref);
-            const result = Reflect.get(obj, this.memory.getObject(name));
+            const key = this.memory.getObject(name);
+            const result = obj[key];
             JSValue.write(
                 result,
                 kind_ptr,
@@ -144,11 +143,8 @@ export class SwiftRuntime {
             payload2: number
         ) => {
             const obj = this.memory.getObject(ref);
-            Reflect.set(
-                obj,
-                index,
-                JSValue.decode(kind, payload1, payload2, this.memory)
-            );
+            const value = JSValue.decode(kind, payload1, payload2, this.memory);
+            obj[index] = value;
         },
 
         swjs_get_subscript: (
@@ -159,7 +155,7 @@ export class SwiftRuntime {
             payload2_ptr: pointer
         ) => {
             const obj = this.memory.getObject(ref);
-            const result = Reflect.get(obj, index);
+            const result = obj[index];
             JSValue.write(
                 result,
                 kind_ptr,
@@ -201,11 +197,8 @@ export class SwiftRuntime {
             const func = this.memory.getObject(ref);
             let result: any;
             try {
-                result = Reflect.apply(
-                    func,
-                    undefined,
-                    JSValue.decodeArray(argv, argc, this.memory)
-                );
+                const args = JSValue.decodeArray(argv, argc, this.memory);
+                result = func(...args);
             } catch (error) {
                 JSValue.write(
                     error,
@@ -237,11 +230,8 @@ export class SwiftRuntime {
             const func = this.memory.getObject(ref);
             let isException = true;
             try {
-                const result = Reflect.apply(
-                    func,
-                    undefined,
-                    JSValue.decodeArray(argv, argc, this.memory)
-                );
+                const args = JSValue.decodeArray(argv, argc, this.memory);
+                const result = func(...args);
                 JSValue.write(
                     result,
                     kind_ptr,
@@ -278,11 +268,8 @@ export class SwiftRuntime {
             const func = this.memory.getObject(func_ref);
             let result: any;
             try {
-                result = Reflect.apply(
-                    func,
-                    obj,
-                    JSValue.decodeArray(argv, argc, this.memory)
-                );
+                const args = JSValue.decodeArray(argv, argc, this.memory);
+                result = func.apply(obj, args);
             } catch (error) {
                 JSValue.write(
                     error,
@@ -317,11 +304,8 @@ export class SwiftRuntime {
             const func = this.memory.getObject(func_ref);
             let isException = true;
             try {
-                const result = Reflect.apply(
-                    func,
-                    obj,
-                    JSValue.decodeArray(argv, argc, this.memory)
-                );
+                const args = JSValue.decodeArray(argv, argc, this.memory);
+                const result = func.apply(obj, args);
                 JSValue.write(
                     result,
                     kind_ptr,
@@ -346,10 +330,8 @@ export class SwiftRuntime {
         },
         swjs_call_new: (ref: ref, argv: pointer, argc: number) => {
             const constructor = this.memory.getObject(ref);
-            const instance = Reflect.construct(
-                constructor,
-                JSValue.decodeArray(argv, argc, this.memory)
-            );
+            const args = JSValue.decodeArray(argv, argc, this.memory);
+            const instance = new constructor(...args);
             return this.memory.retain(instance);
         },
 
@@ -364,10 +346,8 @@ export class SwiftRuntime {
             const constructor = this.memory.getObject(ref);
             let result: any;
             try {
-                result = Reflect.construct(
-                    constructor,
-                    JSValue.decodeArray(argv, argc, this.memory)
-                );
+                const args = JSValue.decodeArray(argv, argc, this.memory);
+                result = new constructor(...args);
             } catch (error) {
                 JSValue.write(
                     error,
diff --git a/Runtime/src/js-value.ts b/Runtime/src/js-value.ts
@@ -10,6 +10,7 @@ export enum Kind {
     Null = 4,
     Undefined = 5,
     Function = 6,
+    Symbol = 7,
 }
 
 export const decode = (
@@ -102,6 +103,11 @@ export const write = (
             memory.writeUint32(payload1_ptr, memory.retain(value));
             break;
         }
+        case "symbol": {
+            memory.writeUint32(kind_ptr, exceptionBit | Kind.Symbol);
+            memory.writeUint32(payload1_ptr, memory.retain(value));
+            break;
+        }
         default:
             throw new Error(`Type "${typeof value}" is not supported yet`);
     }
diff --git a/Runtime/src/object-heap.ts b/Runtime/src/object-heap.ts
@@ -22,33 +22,25 @@ export class SwiftRuntimeHeap {
     }
 
     retain(value: any) {
-        const isObject = typeof value == "object";
         const entry = this._heapEntryByValue.get(value);
-        if (isObject && entry) {
+        if (entry) {
             entry.rc++;
             return entry.id;
         }
         const id = this._heapNextKey++;
         this._heapValueById.set(id, value);
-        if (isObject) {
-            this._heapEntryByValue.set(value, { id: id, rc: 1 });
-        }
+        this._heapEntryByValue.set(value, { id: id, rc: 1 });
         return id;
     }
 
     release(ref: ref) {
         const value = this._heapValueById.get(ref);
-        const isObject = typeof value == "object";
-        if (isObject) {
-            const entry = this._heapEntryByValue.get(value)!;
-            entry.rc--;
-            if (entry.rc != 0) return;
-
-            this._heapEntryByValue.delete(value);
-            this._heapValueById.delete(ref);
-        } else {
-            this._heapValueById.delete(ref);
-        }
+        const entry = this._heapEntryByValue.get(value)!;
+        entry.rc--;
+        if (entry.rc != 0) return;
+
+        this._heapEntryByValue.delete(value);
+        this._heapValueById.delete(ref);
     }
 
     referenceHeap(ref: ref) {
diff --git a/Sources/JavaScriptKit/ConvertibleToJSValue.swift b/Sources/JavaScriptKit/ConvertibleToJSValue.swift
@@ -207,6 +207,8 @@ extension RawJSValue: ConvertibleToJSValue {
             return .undefined
         case .function:
             return .function(JSFunction(id: UInt32(payload1)))
+        case .symbol:
+            return .symbol(JSSymbol(id: UInt32(payload1)))
         }
     }
 }
@@ -238,6 +240,9 @@ extension JSValue {
         case let .function(functionRef):
             kind = .function
             payload1 = JavaScriptPayload1(functionRef.id)
+        case let .symbol(symbolRef):
+            kind = .symbol
+            payload1 = JavaScriptPayload1(symbolRef.id)
         }
         let rawValue = RawJSValue(kind: kind, payload1: payload1, payload2: payload2)
         return body(rawValue)
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift
@@ -11,15 +11,14 @@ import _CJavaScriptKit
 /// ```
 ///
 public class JSFunction: JSObject {
-
     /// Call this function with given `arguments` and binding given `this` as context.
     /// - Parameters:
     ///   - this: The value to be passed as the `this` parameter to this function.
     ///   - arguments: Arguments to be passed to this function.
     /// - Returns: The result of this call.
     @discardableResult
     public func callAsFunction(this: JSObject? = nil, arguments: [ConvertibleToJSValue]) -> JSValue {
-        invokeNonThrowingJSFunction(self, arguments: arguments, this: this)
+        invokeNonThrowingJSFunction(self, arguments: arguments, this: this).jsValue
     }
 
     /// A variadic arguments version of `callAsFunction`.
@@ -41,7 +40,7 @@ public class JSFunction: JSObject {
     public func new(arguments: [ConvertibleToJSValue]) -> JSObject {
         arguments.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer in
-                return JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))
+                JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))
             }
         }
     }
@@ -75,7 +74,7 @@ public class JSFunction: JSObject {
         fatalError("unavailable")
     }
 
-    public override class func construct(from value: JSValue) -> Self? {
+    override public class func construct(from value: JSValue) -> Self? {
         return value.function as? Self
     }
 
@@ -84,18 +83,18 @@ public class JSFunction: JSObject {
     }
 }
 
-private func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> JSValue {
+func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> RawJSValue {
     arguments.withRawJSValues { rawValues in
-        rawValues.withUnsafeBufferPointer { bufferPointer -> (JSValue) in
+        rawValues.withUnsafeBufferPointer { bufferPointer in
             let argv = bufferPointer.baseAddress
             let argc = bufferPointer.count
             var kindAndFlags = JavaScriptValueKindAndFlags()
             var payload1 = JavaScriptPayload1()
             var payload2 = JavaScriptPayload2()
             if let thisId = this?.id {
                 _call_function_with_this_no_catch(thisId,
-                                         jsFunc.id, argv, Int32(argc),
-                                         &kindAndFlags, &payload1, &payload2)
+                                                  jsFunc.id, argv, Int32(argc),
+                                                  &kindAndFlags, &payload1, &payload2)
             } else {
                 _call_function_no_catch(
                     jsFunc.id, argv, Int32(argc),
@@ -104,7 +103,7 @@ private func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [Conve
             }
             assert(!kindAndFlags.isException)
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
-            return result.jsValue
+            return result
         }
     }
 }
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift b/Sources/JavaScriptKit/FundamentalObjects/JSObject.swift
@@ -95,6 +95,14 @@ public class JSObject: Equatable {
         set { setJSValue(this: self, index: Int32(index), value: newValue) }
     }
 
+    /// Access the `symbol` member dynamically through JavaScript and Swift runtime bridge library.
+    /// - Parameter symbol: The name of this object's member to access.
+    /// - Returns: The value of the `name` member of this object.
+    public subscript(_ name: JSSymbol) -> JSValue {
+        get { getJSValue(this: self, symbol: name) }
+        set { setJSValue(this: self, symbol: name, value: newValue) }
+    }
+
     /// A modifier to call methods as throwing methods capturing `this`
     ///
     ///
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSSymbol.swift b/Sources/JavaScriptKit/FundamentalObjects/JSSymbol.swift
@@ -0,0 +1,56 @@
+import _CJavaScriptKit
+
+private let Symbol = JSObject.global.Symbol.function!
+
+public class JSSymbol: JSObject {
+    public var name: String? { self["description"].string }
+
+    public init(_ description: JSString) {
+        // can’t do `self =` so we have to get the ID manually
+        let result = invokeNonThrowingJSFunction(Symbol, arguments: [description], this: nil)
+        precondition(result.kind == .symbol)
+        super.init(id: UInt32(result.payload1))
+    }
+    @_disfavoredOverload
+    public convenience init(_ description: String) {
+        self.init(JSString(description))
+    }
+
+    override init(id: JavaScriptObjectRef) {
+        super.init(id: id)
+    }
+
+    public static func `for`(key: JSString) -> JSSymbol {
+        Symbol.for!(key).symbol!
+    }
+
+    @_disfavoredOverload
+    public static func `for`(key: String) -> JSSymbol {
+        Symbol.for!(key).symbol!
+    }
+
+    public static func key(for symbol: JSSymbol) -> JSString? {
+        Symbol.keyFor!(symbol).jsString
+    }
+
+    @_disfavoredOverload
+    public static func key(for symbol: JSSymbol) -> String? {
+        Symbol.keyFor!(symbol).string
+    }
+}
+
+extension JSSymbol {
+    public static let asyncIterator: JSSymbol! = Symbol.asyncIterator.symbol
+    public static let hasInstance: JSSymbol! = Symbol.hasInstance.symbol
+    public static let isConcatSpreadable: JSSymbol! = Symbol.isConcatSpreadable.symbol
+    public static let iterator: JSSymbol! = Symbol.iterator.symbol
+    public static let match: JSSymbol! = Symbol.match.symbol
+    public static let matchAll: JSSymbol! = Symbol.matchAll.symbol
+    public static let replace: JSSymbol! = Symbol.replace.symbol
+    public static let search: JSSymbol! = Symbol.search.symbol
+    public static let species: JSSymbol! = Symbol.species.symbol
+    public static let split: JSSymbol! = Symbol.split.symbol
+    public static let toPrimitive: JSSymbol! = Symbol.toPrimitive.symbol
+    public static let toStringTag: JSSymbol! = Symbol.toStringTag.symbol
+    public static let unscopables: JSSymbol! = Symbol.unscopables.symbol
+}
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

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ export enum Kind {`
`10`	`10`	`Null = 4,`
`11`	`11`	`Undefined = 5,`
`12`	`12`	`Function = 6,`
	`13`	`+ Symbol = 7,`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`export const decode = (`
`@@ -102,6 +103,11 @@ export const write = (`
`102`	`103`	`memory.writeUint32(payload1_ptr, memory.retain(value));`
`103`	`104`	`break;`
`104`	`105`	`}`
	`106`	`+ case "symbol": {`
	`107`	`+ memory.writeUint32(kind_ptr, exceptionBit \| Kind.Symbol);`
	`108`	`+ memory.writeUint32(payload1_ptr, memory.retain(value));`
	`109`	`+ break;`
	`110`	`+ }`
`105`	`111`	`default:`
`106`	`112`	throw new Error(`Type "${typeof value}" is not supported yet`);
`107`	`113`	`}`
Original file line number	Diff line number	Diff line change
`@@ -207,6 +207,8 @@ extension RawJSValue: ConvertibleToJSValue {`
`207`	`207`	`return .undefined`
`208`	`208`	`case .function:`
`209`	`209`	`return .function(JSFunction(id: UInt32(payload1)))`
	`210`	`+ case .symbol:`
	`211`	`+ return .symbol(JSSymbol(id: UInt32(payload1)))`
`210`	`212`	`}`
`211`	`213`	`}`
`212`	`214`	`}`
`@@ -238,6 +240,9 @@ extension JSValue {`
`238`	`240`	`case let .function(functionRef):`
`239`	`241`	`kind = .function`
`240`	`242`	`payload1 = JavaScriptPayload1(functionRef.id)`
	`243`	`+ case let .symbol(symbolRef):`
	`244`	`+ kind = .symbol`
	`245`	`+ payload1 = JavaScriptPayload1(symbolRef.id)`
`241`	`246`	`}`
`242`	`247`	`let rawValue = RawJSValue(kind: kind, payload1: payload1, payload2: payload2)`
`243`	`248`	`return body(rawValue)`
Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,14 @@ import _CJavaScriptKit`
`11`	`11`	/// ```
`12`	`12`	`///`
`13`	`13`	`public class JSFunction: JSObject {`
`14`		`-`
`15`	`14`	/// Call this function with given `arguments` and binding given `this` as context.
`16`	`15`	`/// - Parameters:`
`17`	`16`	/// - this: The value to be passed as the `this` parameter to this function.
`18`	`17`	`/// - arguments: Arguments to be passed to this function.`
`19`	`18`	`/// - Returns: The result of this call.`
`20`	`19`	`@discardableResult`
`21`	`20`	`public func callAsFunction(this: JSObject? = nil, arguments: [ConvertibleToJSValue]) -> JSValue {`
`22`		`- invokeNonThrowingJSFunction(self, arguments: arguments, this: this)`
	`21`	`+ invokeNonThrowingJSFunction(self, arguments: arguments, this: this).jsValue`
`23`	`22`	`}`
`24`	`23`
`25`	`24`	/// A variadic arguments version of `callAsFunction`.
`@@ -41,7 +40,7 @@ public class JSFunction: JSObject {`
`41`	`40`	`public func new(arguments: [ConvertibleToJSValue]) -> JSObject {`
`42`	`41`	`arguments.withRawJSValues { rawValues in`
`43`	`42`	`rawValues.withUnsafeBufferPointer { bufferPointer in`
`44`		`- return JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))`
	`43`	`+ JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))`
`45`	`44`	`}`
`46`	`45`	`}`
`47`	`46`	`}`
`@@ -75,7 +74,7 @@ public class JSFunction: JSObject {`
`75`	`74`	`fatalError("unavailable")`
`76`	`75`	`}`
`77`	`76`
`78`		`- public override class func construct(from value: JSValue) -> Self? {`
	`77`	`+ override public class func construct(from value: JSValue) -> Self? {`
`79`	`78`	`return value.function as? Self`
`80`	`79`	`}`
`81`	`80`
`@@ -84,18 +83,18 @@ public class JSFunction: JSObject {`
`84`	`83`	`}`
`85`	`84`	`}`
`86`	`85`
`87`		`-private func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> JSValue {`
	`86`	`+func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> RawJSValue {`
`88`	`87`	`arguments.withRawJSValues { rawValues in`
`89`		`- rawValues.withUnsafeBufferPointer { bufferPointer -> (JSValue) in`
	`88`	`+ rawValues.withUnsafeBufferPointer { bufferPointer in`
`90`	`89`	`let argv = bufferPointer.baseAddress`
`91`	`90`	`let argc = bufferPointer.count`
`92`	`91`	`var kindAndFlags = JavaScriptValueKindAndFlags()`
`93`	`92`	`var payload1 = JavaScriptPayload1()`
`94`	`93`	`var payload2 = JavaScriptPayload2()`
`95`	`94`	`if let thisId = this?.id {`
`96`	`95`	`_call_function_with_this_no_catch(thisId,`
`97`		`- jsFunc.id, argv, Int32(argc),`
`98`		`- &kindAndFlags, &payload1, &payload2)`
	`96`	`+ jsFunc.id, argv, Int32(argc),`
	`97`	`+ &kindAndFlags, &payload1, &payload2)`
`99`	`98`	`} else {`
`100`	`99`	`_call_function_no_catch(`
`101`	`100`	`jsFunc.id, argv, Int32(argc),`
`@@ -104,7 +103,7 @@ private func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [Conve`
`104`	`103`	`}`
`105`	`104`	`assert(!kindAndFlags.isException)`
`106`	`105`	`let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)`
`107`		`- return result.jsValue`
	`106`	`+ return result`
`108`	`107`	`}`
`109`	`108`	`}`
`110`	`109`	`}`