Embedded Swift support [WIP]

Package.swift

@@ -1,14 +1,55 @@
-// swift-tools-version:5.7
+// swift-tools-version:5.10
 
 import PackageDescription
 
+let embeddedSwiftSettings: [SwiftSetting] = [
+    .enableExperimentalFeature("Embedded"),
+    .interoperabilityMode(.Cxx),
+    .unsafeFlags([
+        "-wmo", "-disable-cmo",
+        "-Xfrontend", "-gnone",
+        "-Xfrontend", "-disable-stack-protector",
+        "-Xfrontend", "-emit-empty-object-file"
+    ])
+]
+
+let embeddedCSettings: [CSetting] = [
+    .unsafeFlags(["-fdeclspec"])
+]
+
+let linkerSettings: [LinkerSetting] = [
+    .unsafeFlags([
+        "-Xclang-linker", "-nostdlib",
+        "-Xlinker", "--no-entry"
+    ])
+]
+
+let libcSettings: [CSetting] = [
+    .define("LACKS_TIME_H"),
+    .define("LACKS_SYS_TYPES_H"),
+    .define("LACKS_STDLIB_H"),
+    .define("LACKS_STRING_H"),
+    .define("LACKS_SYS_MMAN_H"),
+    .define("LACKS_FCNTL_H"),
+    .define("NO_MALLOC_STATS", to: "1"),
+    .define("__wasilibc_unmodified_upstream"),
+]
+
 let package = Package(
     name: "JavaScriptKit",
     products: [
         .library(name: "JavaScriptKit", targets: ["JavaScriptKit"]),
         .library(name: "JavaScriptEventLoop", targets: ["JavaScriptEventLoop"]),
         .library(name: "JavaScriptBigIntSupport", targets: ["JavaScriptBigIntSupport"]),
         .library(name: "JavaScriptEventLoopTestSupport", targets: ["JavaScriptEventLoopTestSupport"]),
+        // Embedded
+        .library(name: "JavaScriptKitEmbedded", targets: ["JavaScriptKitEmbedded"]),
+        .library(name: "JavaScriptEventLoopEmbedded", targets: ["JavaScriptEventLoopEmbedded"]),
+        .library(name: "JavaScriptBigIntSupportEmbedded", targets: ["JavaScriptBigIntSupportEmbedded"]),
+        .library(name: "JavaScriptEventLoopTestSupportEmbedded", targets: ["JavaScriptEventLoopTestSupportEmbedded"]),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/swifweb/String16", branch: "0.1.0")
     ],
     targets: [
         .target(
@@ -36,11 +77,64 @@ let package = Package(
         ),
         .target(name: "_CJavaScriptEventLoopTestSupport"),
         .testTarget(
-          name: "JavaScriptEventLoopTestSupportTests",
-          dependencies: [
-            "JavaScriptKit",
-            "JavaScriptEventLoopTestSupport"
-          ]
+            name: "JavaScriptEventLoopTestSupportTests",
+            dependencies: [
+                "JavaScriptKit",
+                "JavaScriptEventLoopTestSupport"
+            ]
+        ),
+        // Embedded
+        .target(
+            name: "JavaScriptKitEmbedded",
+            dependencies: [
+                "_CJavaScriptKitEmbedded",
+                .product(name: "String16", package: "String16")
+            ],
+//            resources: [.copy("Runtime")], // FIXME: doesn't work with embedded because trying to import Foundation
+            cSettings: embeddedCSettings,
+            swiftSettings: embeddedSwiftSettings,
+            linkerSettings: linkerSettings
+        ),
+        .target(
+            name: "_CJavaScriptKitEmbedded",
+            cSettings: libcSettings
+        ),
+        .target(
+            name: "JavaScriptBigIntSupportEmbedded",
+            dependencies: ["_CJavaScriptBigIntSupportEmbedded", "JavaScriptKitEmbedded"],
+            cSettings: embeddedCSettings,
+            swiftSettings: embeddedSwiftSettings,
+            linkerSettings: linkerSettings
+        ),
+        .target(
+            name: "_CJavaScriptBigIntSupportEmbedded",
+            dependencies: ["_CJavaScriptKitEmbedded"],
+            cSettings: libcSettings
+        ),
+        .target(
+            name: "JavaScriptEventLoopEmbedded",
+            dependencies: ["JavaScriptKitEmbedded", "_CJavaScriptEventLoopEmbedded"],
+            cSettings: embeddedCSettings,
+            swiftSettings: embeddedSwiftSettings,
+            linkerSettings: linkerSettings
+        ),
+        .target(
+            name: "_CJavaScriptEventLoopEmbedded",
+            cSettings: libcSettings
+        ),
+        .target(
+            name: "JavaScriptEventLoopTestSupportEmbedded",
+            dependencies: [
+                "_CJavaScriptEventLoopTestSupportEmbedded",
+                "JavaScriptEventLoopEmbedded",
+            ],
+            cSettings: embeddedCSettings,
+            swiftSettings: embeddedSwiftSettings,
+            linkerSettings: linkerSettings
+        ),
+        .target(
+            name: "_CJavaScriptEventLoopTestSupportEmbedded",
+            cSettings: libcSettings
         ),
     ]
 )

Package@swift-5.7.swift

@@ -0,0 +1,46 @@
+// swift-tools-version:5.7
+
+import PackageDescription
+
+let package = Package(
+    name: "JavaScriptKit",
+    products: [
+        .library(name: "JavaScriptKit", targets: ["JavaScriptKit"]),
+        .library(name: "JavaScriptEventLoop", targets: ["JavaScriptEventLoop"]),
+        .library(name: "JavaScriptBigIntSupport", targets: ["JavaScriptBigIntSupport"]),
+        .library(name: "JavaScriptEventLoopTestSupport", targets: ["JavaScriptEventLoopTestSupport"]),
+    ],
+    targets: [
+        .target(
+            name: "JavaScriptKit",
+            dependencies: ["_CJavaScriptKit"],
+            resources: [.copy("Runtime")]
+        ),
+        .target(name: "_CJavaScriptKit"),
+        .target(
+            name: "JavaScriptBigIntSupport",
+            dependencies: ["_CJavaScriptBigIntSupport", "JavaScriptKit"]
+        ),
+        .target(name: "_CJavaScriptBigIntSupport", dependencies: ["_CJavaScriptKit"]),
+        .target(
+            name: "JavaScriptEventLoop",
+            dependencies: ["JavaScriptKit", "_CJavaScriptEventLoop"]
+        ),
+        .target(name: "_CJavaScriptEventLoop"),
+        .target(
+            name: "JavaScriptEventLoopTestSupport",
+            dependencies: [
+                "_CJavaScriptEventLoopTestSupport",
+                "JavaScriptEventLoop",
+            ]
+        ),
+        .target(name: "_CJavaScriptEventLoopTestSupport"),
+        .testTarget(
+          name: "JavaScriptEventLoopTestSupportTests",
+          dependencies: [
+            "JavaScriptKit",
+            "JavaScriptEventLoopTestSupport"
+          ]
+        ),
+    ]
+)

Runtime/src/index.ts

@@ -21,7 +21,8 @@ export class SwiftRuntime {
     private options: SwiftRuntimeOptions;
     private version: number = 708;
 
-    private textDecoder = new TextDecoder("utf-8");
+    private textDecoderUTF8 = new TextDecoder("utf-8");
+    private textDecoderUTF16 = new TextDecoder("utf-16");
     private textEncoder = new TextEncoder(); // Only support utf-8
 
     constructor(options?: SwiftRuntimeOptions) {
@@ -210,6 +211,13 @@ export class SwiftRuntime {
                 memory.writeUint32(bytes_ptr_result, bytes_ptr);
                 return bytes.length;
             },
+            swjs_encode_utf16_string: (ref: ref, bytes_ptr_result: pointer) => {
+                const memory = this.memory;
+                const bytes = memory.getObject(ref);
+                const bytes_ptr = memory.retain(bytes);
+                memory.writeUint32(bytes_ptr_result, bytes_ptr);
+                return bytes.length;
+            },
             swjs_decode_string: (
                 // NOTE: TextDecoder can't decode typed arrays backed by SharedArrayBuffer
                 this.options.sharedMemory == true
@@ -218,15 +226,35 @@ export class SwiftRuntime {
                     const bytes = memory
                         .bytes()
                         .slice(bytes_ptr, bytes_ptr + length);
-                    const string = this.textDecoder.decode(bytes);
+                    const string = this.textDecoderUTF8.decode(bytes);
+                    return memory.retain(string);
+                })
+                : ((bytes_ptr: pointer, length: number) => {
+                    const memory = this.memory;
+                    const bytes = memory
+                        .bytes()
+                        .subarray(bytes_ptr, bytes_ptr + length);
+                    const string = this.textDecoderUTF8.decode(bytes);
+                    return memory.retain(string);
+                })
+            ),
+            swjs_decode_utf16_string: (
+                // NOTE: TextDecoder can't decode typed arrays backed by SharedArrayBuffer
+                this.options.sharedMemory == true
+                ? ((bytes_ptr: pointer, length: number) => {
+                    const memory = this.memory;
+                    const bytes = memory
+                        .bytes()
+                        .slice(bytes_ptr, bytes_ptr + length);
+                    const string = this.textDecoderUTF16.decode(bytes);
                     return memory.retain(string);
                 })
                 : ((bytes_ptr: pointer, length: number) => {
                     const memory = this.memory;
                     const bytes = memory
                         .bytes()
                         .subarray(bytes_ptr, bytes_ptr + length);
-                    const string = this.textDecoder.decode(bytes);
+                    const string = this.textDecoderUTF16.decode(bytes);
                     return memory.retain(string);
                 })
             ),

Runtime/src/types.ts

@@ -49,7 +49,9 @@ export interface ImportedFunctions {
         payload2_ptr: pointer
     ): JavaScriptValueKind;
     swjs_encode_string(ref: number, bytes_ptr_result: pointer): number;
+    swjs_encode_utf16_string(ref: number, bytes_ptr_result: pointer): number;
     swjs_decode_string(bytes_ptr: pointer, length: number): number;
+    swjs_decode_utf16_string(bytes_ptr: pointer, length: number): number;
     swjs_load_string(ref: number, buffer: pointer): void;
     swjs_call_function(
         ref: number,

Sources/JavaScriptBigIntSupportEmbedded

@@ -0,0 +1 @@
+JavaScriptBigIntSupport

Sources/JavaScriptEventLoopEmbedded

@@ -0,0 +1 @@
+JavaScriptEventLoop

Sources/JavaScriptEventLoopTestSupportEmbedded

@@ -0,0 +1 @@
+JavaScriptEventLoopTestSupport

Sources/JavaScriptKit/BasicObjects/JSArray.swift

@@ -5,7 +5,11 @@ public class JSArray: JSBridgedClass {
     public static let constructor = JSObject.global.Array.function
 
     static func isArray(_ object: JSObject) -> Bool {
+        #if hasFeature(Embedded)
+        constructor!.isArray!(object.jsValue).boolean!
+        #else
         constructor!.isArray!(object).boolean!
+        #endif
     }
 
     public let jsObject: JSObject
@@ -51,9 +55,15 @@ extension JSArray: RandomAccessCollection {
                 return nil
             }
             index += 1
+            #if hasFeature(Embedded)
+            guard jsObject.hasOwnProperty!(currentIndex.jsValue).boolean! else {
+                return next()
+            }
+            #else
             guard jsObject.hasOwnProperty!(currentIndex).boolean! else {
                 return next()
             }
+            #endif
             let value = jsObject[currentIndex]
             return value
         }
@@ -91,11 +101,18 @@ extension JSArray: RandomAccessCollection {
     }
 }
 
+#if hasFeature(Embedded)
+private func getObjectValuesLength(_ object: JSObject) -> Int {
+   let values = object.filter!((JSClosure { _ in true.jsValue }).jsValue).object!
+   return Int(values.length.number!)
+}
+#else
 private let alwaysTrue = JSClosure { _ in .boolean(true) }
 private func getObjectValuesLength(_ object: JSObject) -> Int {
     let values = object.filter!(alwaysTrue).object!
     return Int(values.length.number!)
 }
+#endif
 
 public extension JSValue {
     var array: JSArray? {