Revert "Revert "Revert "Add support for Symbol objects via JSSymbol (#179)"""

This reverts commit 6b07c4f.

Author: j-f1

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -804,28 +804,5 @@ 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: Object.assign(function () {}, {
-    //     [Symbol.hasInstance]() { return true }
-    //   })
-    // }.prop
-    let hasInstanceObject = JSObject.global.Object.function!.new()
-    hasInstanceObject.prop = JSClosure { _ in .undefined }.jsValue
-    let hasInstanceClass = hasInstanceObject.prop.function!
-    hasInstanceClass[JSSymbol.hasInstance] = JSClosure { _ in
-        return .boolean(true)
-    }.jsValue
-    try expectEqual(hasInstanceClass[JSSymbol.hasInstance].function!().boolean, true)
-    try expectEqual(JSObject.global.Object.isInstanceOf(hasInstanceClass), true)
-}
 
 Expectation.wait(expectations)

Runtime/src/js-value.ts

@@ -10,7 +10,6 @@ export enum Kind {
     Null = 4,
     Undefined = 5,
     Function = 6,
-    Symbol = 7,
 }
 
 export const decode = (
@@ -103,11 +102,6 @@ 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`);
     }

Runtime/src/object-heap.ts

@@ -22,25 +22,33 @@ export class SwiftRuntimeHeap {
     }
 
     retain(value: any) {
+        const isObject = typeof value == "object";
         const entry = this._heapEntryByValue.get(value);
-        if (entry) {
+        if (isObject && entry) {
             entry.rc++;
             return entry.id;
         }
         const id = this._heapNextKey++;
         this._heapValueById.set(id, value);
-        this._heapEntryByValue.set(value, { id: id, rc: 1 });
+        if (isObject) {
+            this._heapEntryByValue.set(value, { id: id, rc: 1 });
+        }
         return id;
     }
 
     release(ref: ref) {
         const value = this._heapValueById.get(ref);
-        const entry = this._heapEntryByValue.get(value)!;
-        entry.rc--;
-        if (entry.rc != 0) return;
-
-        this._heapEntryByValue.delete(value);
-        this._heapValueById.delete(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);
+        }
     }
 
     referenceHeap(ref: ref) {

Sources/JavaScriptKit/ConvertibleToJSValue.swift

@@ -207,8 +207,6 @@ extension RawJSValue: ConvertibleToJSValue {
             return .undefined
         case .function:
             return .function(JSFunction(id: UInt32(payload1)))
-        case .symbol:
-            return .symbol(JSSymbol(id: UInt32(payload1)))
         }
     }
 }
@@ -240,9 +238,6 @@ 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)

Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift

@@ -11,14 +11,15 @@ 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).jsValue
+        invokeNonThrowingJSFunction(self, arguments: arguments, this: this)
     }
 
     /// A variadic arguments version of `callAsFunction`.
@@ -40,7 +41,7 @@ public class JSFunction: JSObject {
     public func new(arguments: [ConvertibleToJSValue]) -> JSObject {
         arguments.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer in
-                JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))
+                return JSObject(id: _call_new(self.id, bufferPointer.baseAddress!, Int32(bufferPointer.count)))
             }
         }
     }
@@ -74,7 +75,7 @@ public class JSFunction: JSObject {
         fatalError("unavailable")
     }
 
-    override public class func construct(from value: JSValue) -> Self? {
+    public override class func construct(from value: JSValue) -> Self? {
         return value.function as? Self
     }
 
@@ -83,18 +84,18 @@ public class JSFunction: JSObject {
     }
 }
 
-func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> RawJSValue {
+private func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSValue], this: JSObject?) -> JSValue {
     arguments.withRawJSValues { rawValues in
-        rawValues.withUnsafeBufferPointer { bufferPointer in
+        rawValues.withUnsafeBufferPointer { bufferPointer -> (JSValue) 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),
@@ -103,7 +104,7 @@ func invokeNonThrowingJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleTo
             }
             assert(!kindAndFlags.isException)
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
-            return result
+            return result.jsValue
         }
     }
 }

Sources/JavaScriptKit/FundamentalObjects/JSObject.swift

@@ -95,14 +95,6 @@ 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`
     ///
     ///

Sources/JavaScriptKit/FundamentalObjects/JSSymbol.swift

@@ -10,7 +10,6 @@ public enum JSValue: Equatable {
     case null
     case undefined
     case function(JSFunction)
-    case symbol(JSSymbol)
 
     /// Returns the `Bool` value of this JS value if its type is boolean.
     /// If not, returns `nil`.
@@ -68,13 +67,6 @@ public enum JSValue: Equatable {
         }
     }
 
-    public var symbol: JSSymbol? {
-        switch self {
-        case let .symbol(symbol): return symbol
-        default: return nil
-        }
-    }
-
     /// Returns the `true` if this JS value is null.
     /// If not, returns `false`.
     public var isNull: Bool {
@@ -88,38 +80,39 @@ public enum JSValue: Equatable {
     }
 }
 
-public extension JSValue {
+extension JSValue {
     /// An unsafe convenience method of `JSObject.subscript(_ name: String) -> ((ConvertibleToJSValue...) -> JSValue)?`
     /// - Precondition: `self` must be a JavaScript Object and specified member should be a callable object.
-    subscript(dynamicMember name: String) -> ((ConvertibleToJSValue...) -> JSValue) {
+    public subscript(dynamicMember name: String) -> ((ConvertibleToJSValue...) -> JSValue) {
         object![dynamicMember: name]!
     }
 
     /// An unsafe convenience method of `JSObject.subscript(_ index: Int) -> JSValue`
     /// - Precondition: `self` must be a JavaScript Object.
-    subscript(dynamicMember name: String) -> JSValue {
+    public subscript(dynamicMember name: String) -> JSValue {
         get { self.object![name] }
         set { self.object![name] = newValue }
     }
 
     /// An unsafe convenience method of `JSObject.subscript(_ index: Int) -> JSValue`
     /// - Precondition: `self` must be a JavaScript Object.
-    subscript(_ index: Int) -> JSValue {
+    public subscript(_ index: Int) -> JSValue {
         get { object![index] }
         set { object![index] = newValue }
     }
 }
 
 extension JSValue: Swift.Error {}
 
-public extension JSValue {
-    func fromJSValue<Type>() -> Type? where Type: ConstructibleFromJSValue {
+extension JSValue {
+    public func fromJSValue<Type>() -> Type? where Type: ConstructibleFromJSValue {
         return Type.construct(from: self)
     }
 }
 
-public extension JSValue {
-    static func string(_ value: String) -> JSValue {
+extension JSValue {
+
+    public static func string(_ value: String) -> JSValue {
         .string(JSString(value))
     }
 
@@ -148,12 +141,12 @@ public extension JSValue {
     /// eventListenter.release()
     /// ```
     @available(*, deprecated, message: "Please create JSClosure directly and manage its lifetime manually.")
-    static func function(_ body: @escaping ([JSValue]) -> JSValue) -> JSValue {
+    public static func function(_ body: @escaping ([JSValue]) -> JSValue) -> JSValue {
         .object(JSClosure(body))
     }
 
     @available(*, deprecated, renamed: "object", message: "JSClosure is no longer a subclass of JSFunction. Use .object(closure) instead.")
-    static func function(_ closure: JSClosure) -> JSValue {
+    public static func function(_ closure: JSClosure) -> JSValue {
         .object(closure)
     }
 }
@@ -177,7 +170,7 @@ extension JSValue: ExpressibleByFloatLiteral {
 }
 
 extension JSValue: ExpressibleByNilLiteral {
-    public init(nilLiteral _: ()) {
+    public init(nilLiteral: ()) {
         self = .null
     }
 }
@@ -212,28 +205,14 @@ public func setJSValue(this: JSObject, index: Int32, value: JSValue) {
     }
 }
 
-public func getJSValue(this: JSObject, symbol: JSSymbol) -> JSValue {
-    var rawValue = RawJSValue()
-    _get_prop(this.id, symbol.id,
-              &rawValue.kind,
-              &rawValue.payload1, &rawValue.payload2)
-    return rawValue.jsValue
-}
-
-public func setJSValue(this: JSObject, symbol: JSSymbol, value: JSValue) {
-    value.withRawJSValue { rawValue in
-        _set_prop(this.id, symbol.id, rawValue.kind, rawValue.payload1, rawValue.payload2)
-    }
-}
-
-public extension JSValue {
-    /// Return `true` if this value is an instance of the passed `constructor` function.
-    /// Returns `false` for everything except objects and functions.
-    /// - Parameter constructor: The constructor function to check.
-    /// - Returns: The result of `instanceof` in the JavaScript environment.
-    func isInstanceOf(_ constructor: JSFunction) -> Bool {
+extension JSValue {
+  /// Return `true` if this value is an instance of the passed `constructor` function.
+  /// Returns `false` for everything except objects and functions.
+  /// - Parameter constructor: The constructor function to check.
+  /// - Returns: The result of `instanceof` in the JavaScript environment.
+    public func isInstanceOf(_ constructor: JSFunction) -> Bool {
         switch self {
-        case .boolean, .string, .number, .null, .undefined, .symbol:
+        case .boolean, .string, .number, .null, .undefined:
             return false
         case let .object(ref):
             return ref.isInstanceOf(constructor)
@@ -248,12 +227,11 @@ extension JSValue: CustomStringConvertible {
         switch self {
         case let .boolean(boolean):
             return boolean.description
-        case let .string(string):
+        case .string(let string):
             return string.description
-        case let .number(number):
+        case .number(let number):
             return number.description
-        case let .object(object), let .function(object as JSObject),
-             .symbol(let object as JSObject):
+        case .object(let object), .function(let object as JSObject):
             return object.toString!().fromJSValue()!
         case .null:
             return "null"