Engine API: Migrate all Runtime usage in ./Tests

Author: kateinoigakukun

Sources/WITOverlayGenerator/HostGenerators/HostWorldGenerator.swift

@@ -23,7 +23,7 @@ struct HostWorldGenerator: ASTVisitor {
                 struct \(ConvertCase.pascalCase(world.name)) {
                     let instance: WasmKit.Instance
 
-                    static func link(_ hostModules: inout [String: HostModule]) {
+                    static func link(to imports: inout Imports, store: Store) {
                     }
                 """)
         // Enter world struct body

Sources/WasmKit/Engine.swift

@@ -11,7 +11,7 @@ public final class Engine {
     /// - Parameters:
     ///   - configuration: The engine configuration.
     ///   - interceptor: An optional runtime interceptor to intercept execution of instructions.
-    public init(configuration: EngineConfiguration, interceptor: EngineInterceptor? = nil) {
+    public init(configuration: EngineConfiguration = EngineConfiguration(), interceptor: EngineInterceptor? = nil) {
         self.configuration = configuration
         self.interceptor = interceptor
         self.funcTypeInterner = Interner()

Sources/WasmKit/Execution/Instances.swift

@@ -367,6 +367,19 @@ public struct Memory: Equatable {
     let handle: InternalMemory
     let allocator: StoreAllocator
 
+    init(handle: InternalMemory, allocator: StoreAllocator) {
+        self.handle = handle
+        self.allocator = allocator
+    }
+
+    /// Creates a new memory instance with the given type.
+    public init(store: Store, type: MemoryType) throws {
+        self.init(
+            handle: try store.allocator.allocate(memoryType: type, resourceLimiter: store.resourceLimiter),
+            allocator: store.allocator
+        )
+    }
+
     /// Returns a copy of the memory data.
     public var data: [UInt8] {
         handle.data

Sources/WasmKitWASI/WASIBridgeToHost+WasmKit.swift

@@ -5,7 +5,6 @@ public typealias WASIBridgeToHost = WASI.WASIBridgeToHost
 
 extension WASIBridgeToHost {
     public func link(to imports: inout Imports, store: Store) {
-        var imports = Imports()
         for (moduleName, module) in wasiHostModules {
             for (name, function) in module.functions {
                 imports.define(

Tests/WASITests/IntegrationTests.swift

@@ -116,10 +116,13 @@ final class IntegrationTests: XCTestCase {
                 $0[$1] = suitePath.appendingPathComponent($1).path
             }
         )
-        let runtime = Runtime(hostModules: wasi.hostModules)
+        let engine = Engine()
+        let store = Store(engine: engine)
+        var imports = Imports()
+        wasi.link(to: &imports, store: store)
         let module = try parseWasm(filePath: FilePath(path.path))
-        let instance = try runtime.instantiate(module: module)
-        let exitCode = try wasi.start(instance, runtime: runtime)
+        let instance = try module.instantiate(store: store, imports: imports)
+        let exitCode = try wasi.start(instance)
         XCTAssertEqual(exitCode, manifest.exitCode ?? 0, path.path)
     }
 }

Tests/WITOverlayGeneratorTests/Runtime/RuntimeSmokeTests.swift

@@ -6,7 +6,7 @@ import XCTest
 class RuntimeSmokeTests: XCTestCase {
     func testCallExportByGuest() throws {
         var harness = try RuntimeTestHarness(fixture: "Smoke")
-        try harness.build(link: SmokeTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: SmokeTestWorld.link) { (instance) in
             let component = SmokeTestWorld(instance: instance)
             _ = try component.hello()
         }

Tests/WITOverlayGeneratorTests/Runtime/RuntimeTestHarness.swift

@@ -123,21 +123,24 @@ struct RuntimeTestHarness {
 
     /// Build up WebAssembly module from the fixture and instantiate WasmKit runtime with the module.
     mutating func build(
-        link: (inout [String: HostModule]) -> Void,
-        run: (Runtime, Instance) throws -> Void
+        link: (inout Imports, Store) -> Void,
+        run: (Instance) throws -> Void
     ) throws {
         for compile in [compileForEmbedded, compileForWASI] {
             defer { cleanupTemporaryFiles() }
             let compiled = try compile(collectGuestInputFiles())
 
+            let engine = Engine()
+            let store = Store(engine: engine)
+
             let wasi = try WASIBridgeToHost(args: [compiled.path])
-            var hostModules: [String: HostModule] = wasi.hostModules
-            link(&hostModules)
+            var imports = Imports()
+            wasi.link(to: &imports, store: store)
+            link(&imports, store)
 
             let module = try parseWasm(filePath: .init(compiled.path))
-            let runtime = Runtime(hostModules: hostModules)
-            let instance = try runtime.instantiate(module: module)
-            try run(runtime, instance)
+            let instance = try module.instantiate(store: store, imports: imports)
+            try run(instance)
         }
     }
 

Tests/WITOverlayGeneratorTests/Runtime/RuntimeTypesTests.swift

@@ -7,7 +7,7 @@ import XCTest
 class RuntimeTypesTests: XCTestCase {
     func testNumber() throws {
         var harness = try RuntimeTestHarness(fixture: "Number")
-        try harness.build(link: NumberTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: NumberTestWorld.link) { (instance) in
             let component = NumberTestWorld(instance: instance)
 
             XCTAssertEqual(try component.roundtripBool(v: true), true)
@@ -74,7 +74,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testChar() throws {
         var harness = try RuntimeTestHarness(fixture: "Char")
-        try harness.build(link: CharTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: CharTestWorld.link) { (instance) in
             let component = CharTestWorld(instance: instance)
 
             for char in "abcd🍏👨‍👩‍👦‍👦".unicodeScalars {
@@ -85,7 +85,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testOption() throws {
         var harness = try RuntimeTestHarness(fixture: "Option")
-        try harness.build(link: OptionTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: OptionTestWorld.link) { (instance) in
             let component = OptionTestWorld(instance: instance)
             let value1 = try component.returnNone()
             XCTAssertEqual(value1, nil)
@@ -111,7 +111,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testRecord() throws {
         var harness = try RuntimeTestHarness(fixture: "Record")
-        try harness.build(link: RecordTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: RecordTestWorld.link) { (instance) in
             let component = RecordTestWorld(instance: instance)
             _ = try component.returnEmpty()
 
@@ -129,7 +129,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testString() throws {
         var harness = try RuntimeTestHarness(fixture: "String")
-        try harness.build(link: StringTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: StringTestWorld.link) { (instance) in
             let component = StringTestWorld(instance: instance)
             XCTAssertEqual(try component.returnEmpty(), "")
             XCTAssertEqual(try component.roundtrip(v: "ok"), "ok")
@@ -142,7 +142,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testList() throws {
         var harness = try RuntimeTestHarness(fixture: "List")
-        try harness.build(link: ListTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: ListTestWorld.link) { (instance) in
             let component = ListTestWorld(instance: instance)
             XCTAssertEqual(try component.returnEmpty(), [])
             for value in [[], [1, 2, 3]] as [[UInt8]] {
@@ -157,7 +157,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testVariant() throws {
         var harness = try RuntimeTestHarness(fixture: "Variant")
-        try harness.build(link: VariantTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: VariantTestWorld.link) { (instance) in
             let component = VariantTestWorld(instance: instance)
             XCTAssertEqual(try component.returnSingle(), .a(33_550_336))
 
@@ -185,7 +185,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testResult() throws {
         var harness = try RuntimeTestHarness(fixture: "Result")
-        try harness.build(link: ResultTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: ResultTestWorld.link) { (instance) in
             let component = ResultTestWorld(instance: instance)
 
             let value4 = try component.roundtripResult(v: .success(()))
@@ -217,7 +217,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testEnum() throws {
         var harness = try RuntimeTestHarness(fixture: "Enum")
-        try harness.build(link: EnumTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: EnumTestWorld.link) { (instance) in
             let component = EnumTestWorld(instance: instance)
 
             let value1 = try component.roundtripSingle(v: .a)
@@ -236,7 +236,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testFlags() throws {
         var harness = try RuntimeTestHarness(fixture: "Flags")
-        try harness.build(link: FlagsTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: FlagsTestWorld.link) { (instance) in
             let component = FlagsTestWorld(instance: instance)
 
             XCTAssertEqual(try component.roundtripSingle(v: []), [])
@@ -260,7 +260,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testTuple() throws {
         var harness = try RuntimeTestHarness(fixture: "Tuple")
-        try harness.build(link: TupleTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: TupleTestWorld.link) { (instance) in
             let component = TupleTestWorld(instance: instance)
             let value1 = try component.roundtrip(v: (true, 42))
             XCTAssertEqual(value1.0, true)
@@ -270,7 +270,7 @@ class RuntimeTypesTests: XCTestCase {
 
     func testInterface() throws {
         var harness = try RuntimeTestHarness(fixture: "Interface")
-        try harness.build(link: InterfaceTestWorld.link(_:)) { (runtime, instance) in
+        try harness.build(link: InterfaceTestWorld.link) { (instance) in
             let component = InterfaceTestWorld(instance: instance)
             let value1 = try component.roundtripT1(v: 42)
             XCTAssertEqual(value1, 42)
@@ -284,7 +284,7 @@ class RuntimeTypesTests: XCTestCase {
     func testNaming() throws {
         // Ensure compilation succeed for both host and guest
         var harness = try RuntimeTestHarness(fixture: "Naming")
-        try harness.build(link: NamingTestWorld.link(_:), run: { _, _ in })
+        try harness.build(link: NamingTestWorld.link, run: { _ in })
     }
 }
 

Tests/WasmKitTests/Execution/HostModuleTests.swift

@@ -6,22 +6,13 @@ import XCTest
 
 final class HostModuleTests: XCTestCase {
     func testImportMemory() throws {
-        let runtime = Runtime()
+        let engine = Engine()
+        let store = Store(engine: engine)
         let memoryType = MemoryType(min: 1, max: nil)
-        let memory = try runtime.store.allocator.allocate(
-            memoryType: memoryType, resourceLimiter: DefaultResourceLimiter())
-        try runtime.register(
-            HostModule(
-                memories: [
-                    "memory": Memory(
-                        handle: memory,
-                        allocator: runtime.store
-                            .allocator
-                    )
-                ]
-            ),
-            as: "env"
-        )
+        let memory = try WasmKit.Memory(store: store, type: memoryType)
+        let imports: Imports = [
+            "env": ["memory": memory]
+        ]
 
         let module = try parseWasm(
             bytes: wat2wasm(
@@ -30,13 +21,14 @@ final class HostModuleTests: XCTestCase {
                     (import "env" "memory" (memory 1))
                 )
                 """))
-        XCTAssertNoThrow(try runtime.instantiate(module: module))
+        XCTAssertNoThrow(try module.instantiate(store: store, imports: imports))
         // Ensure the allocated address is valid
         _ = memory.data
     }
 
     func testReentrancy() throws {
-        let runtime = Runtime()
+        let engine = Engine()
+        let store = Store(engine: engine)
         let voidSignature = WasmTypes.FunctionType(parameters: [], results: [])
         let module = try parseWasm(
             bytes: wat2wasm(
@@ -58,9 +50,9 @@ final class HostModuleTests: XCTestCase {
 
         var isExecutingFoo = false
         var isQuxCalled = false
-        let hostModule = HostModule(
-            functions: [
-                "bar": HostFunction(type: voidSignature) { caller, _ in
+        let imports: Imports = [
+            "env": [
+                "bar": Function(store: store, type: voidSignature) { caller, _ in
                     // Ensure "invoke" executes instructions under the current call
                     XCTAssertFalse(isExecutingFoo, "bar should not be called recursively")
                     isExecutingFoo = true
@@ -69,17 +61,17 @@ final class HostModuleTests: XCTestCase {
                     _ = try foo()
                     return []
                 },
-                "qux": HostFunction(type: voidSignature) { _, _ in
+                "qux": Function(store: store, type: voidSignature) { caller, _ in
                     XCTAssertTrue(isExecutingFoo)
                     isQuxCalled = true
                     return []
                 },
             ]
-        )
-        try runtime.register(hostModule, as: "env")
-        let instance = try runtime.instantiate(module: module)
+        ]
+        let instance = try module.instantiate(store: store, imports: imports)
         // Check foo(wasm) -> bar(host) -> baz(wasm) -> qux(host)
-        _ = try runtime.invoke(instance, function: "foo")
+        let foo = try XCTUnwrap(instance.exports[function: "foo"])
+        try foo()
         XCTAssertTrue(isQuxCalled)
     }
 }

Tests/WasmKitTests/Execution/Runtime/StoreAllocatorTests.swift

@@ -34,9 +34,10 @@ final class StoreAllocatorTests: XCTestCase {
                 (memory (;0;) 0)
                 (export "a" (memory 0)))
             """))
-            let runtime = Runtime()
-            _ = try runtime.instantiate(module: module)
-            weakAllocator = runtime.store.allocator
+            let engine = Engine()
+            let store = Store(engine: engine)
+            _ = try module.instantiate(store: store)
+            weakAllocator = store.allocator
         }
         XCTAssertNil(weakAllocator)
     }