Unify JavaScriptValueKindAndFlags type across non-/Embedded builds

Author: kateinoigakukun

Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift

@@ -136,7 +136,7 @@ public class JSFunction: JSObject, _JSFunctionProtocol {
                 id, argv, Int32(argc),
                 &payload1, &payload2
             )
-            let kindAndFlags = valueKindAndFlagsFromBits(resultBitPattern)
+            let kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             assert(!kindAndFlags.isException)
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
             return result
@@ -153,7 +153,7 @@ public class JSFunction: JSObject, _JSFunctionProtocol {
                 id, argv, Int32(argc),
                 &payload1, &payload2
             )
-            let kindAndFlags = valueKindAndFlagsFromBits(resultBitPattern)
+            let kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             #if !hasFeature(Embedded)
             assert(!kindAndFlags.isException)
             #endif
@@ -241,25 +241,15 @@ public extension _JSFunctionProtocol {
         new(arguments: [arg0.jsValue, arg1.jsValue, arg2.jsValue, arg3.jsValue, arg4.jsValue, arg5.jsValue, arg6.jsValue])
     }
 }
+#endif
 
-// C bit fields seem to not work with Embedded
-// in "normal mode" this is defined as a C struct
-private struct JavaScriptValueKindAndFlags {
-    let errorBit: UInt32 = 1 << 32
+internal struct JavaScriptValueKindAndFlags {
+    static var errorBit: UInt32 { 1 << 31 }
     let kind: JavaScriptValueKind
     let isException: Bool
 
     init(bitPattern: UInt32) {
-        self.kind = JavaScriptValueKind(rawValue: bitPattern & ~errorBit)!
-        self.isException = (bitPattern & errorBit) != 0
+        self.kind = JavaScriptValueKind(rawValue: bitPattern & ~Self.errorBit)!
+        self.isException = (bitPattern & Self.errorBit) != 0
     }
 }
-#endif
-
-private func valueKindAndFlagsFromBits(_ bits: UInt32) -> JavaScriptValueKindAndFlags {
-    #if hasFeature(Embedded)
-    JavaScriptValueKindAndFlags(bitPattern: bits)
-    #else 
-    unsafeBitCast(bits, to: JavaScriptValueKindAndFlags.self)
-    #endif
-}

Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift

@@ -42,13 +42,14 @@ public class JSThrowingFunction {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
 
-                var exceptionKind = JavaScriptValueKindAndFlags()
+                var exceptionRawKind = JavaScriptRawValueKindAndFlags()
                 var exceptionPayload1 = JavaScriptPayload1()
                 var exceptionPayload2 = JavaScriptPayload2()
                 let resultObj = swjs_call_throwing_new(
                     self.base.id, argv, Int32(argc),
-                    &exceptionKind, &exceptionPayload1, &exceptionPayload2
+                    &exceptionRawKind, &exceptionPayload1, &exceptionPayload2
                 )
+                let exceptionKind = JavaScriptValueKindAndFlags(bitPattern: exceptionRawKind)
                 if exceptionKind.isException {
                     let exception = RawJSValue(kind: exceptionKind.kind, payload1: exceptionPayload1, payload2: exceptionPayload2)
                     return .failure(exception.jsValue)
@@ -70,21 +71,21 @@ private func invokeJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSV
         rawValues.withUnsafeBufferPointer { bufferPointer -> (JSValue, Bool) in
             let argv = bufferPointer.baseAddress
             let argc = bufferPointer.count
-            var kindAndFlags = JavaScriptValueKindAndFlags()
+            let kindAndFlags: JavaScriptValueKindAndFlags
             var payload1 = JavaScriptPayload1()
             var payload2 = JavaScriptPayload2()
             if let thisId = this?.id {
                 let resultBitPattern = swjs_call_function_with_this(
                     thisId, id, argv, Int32(argc),
                     &payload1, &payload2
                 )
-                kindAndFlags = unsafeBitCast(resultBitPattern, to: JavaScriptValueKindAndFlags.self)
+                kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             } else {
                 let resultBitPattern = swjs_call_function(
                     id, argv, Int32(argc),
                     &payload1, &payload2
                 )
-                kindAndFlags = unsafeBitCast(resultBitPattern, to: JavaScriptValueKindAndFlags.self)
+                kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             }
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
             return (result.jsValue, kindAndFlags.isException)
@@ -95,4 +96,4 @@ private func invokeJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSV
     }
     return result
 }
-#endif
+#endif

Sources/_CJavaScriptKit/include/_CJavaScriptKit.h

@@ -29,15 +29,7 @@ typedef enum __attribute__((enum_extensibility(closed))) {
   JavaScriptValueKindBigInt = 8,
 } JavaScriptValueKind;
 
-#if __Embedded
-// something about the bit field widths is not working with embedded
-typedef unsigned short JavaScriptValueKindAndFlags;
-#else
-typedef struct {
-  JavaScriptValueKind kind: 31;
-  bool isException: 1;
-} JavaScriptValueKindAndFlags;
-#endif
+typedef uint32_t JavaScriptRawValueKindAndFlags;
 
 typedef unsigned JavaScriptPayload1;
 typedef double JavaScriptPayload2;
@@ -253,7 +245,7 @@ IMPORT_JS_FUNCTION(swjs_call_new, JavaScriptObjectRef, (const JavaScriptObjectRe
 IMPORT_JS_FUNCTION(swjs_call_throwing_new, JavaScriptObjectRef, (const JavaScriptObjectRef ref,
                                                                  const RawJSValue *argv,
                                                                  const int argc,
-                                                                 JavaScriptValueKindAndFlags *exception_kind,
+                                                                 JavaScriptRawValueKindAndFlags *exception_kind,
                                                                  JavaScriptPayload1 *exception_payload1,
                                                                  JavaScriptPayload2 *exception_payload2))