PackageToJS: Generate each test bundle's glue from what its binary links in

`js test` generated the glue from every test target's skeletons and handed
the same copy to each SwiftBuild per-target runner, which described exports
those binaries don't have. Package the aggregated glue once into the shared
base directory, where preludes import it by a fixed path, and give each
runner glue scoped to the target it links in.

This supersedes the registration guard in the JS code generator.

Author: kateinoigakukun

Plugins/PackageToJS/Sources/PackageToJS.swift

@@ -614,54 +614,13 @@ struct PackagingPlanner {
         packageInputs.append(packageJsonTask)
 
         if !skeletons.isEmpty {
-            let bridge = try loadBridgeJS()
-            let skeletonFiles = skeletons.map { BuildPath(absolute: $0.source.path) }
-            let bridgeJs = outputDir.appending(path: "bridge-js.js")
-            let bridgeDts = outputDir.appending(path: "bridge-js.d.ts")
-            let bridgeModules = outputDir.appending(path: "bridge-js-modules")
             packageInputs.append(
-                make.addTask(
-                    inputFiles: skeletonFiles + [selfPath, wasmImportsPath],
-                    inputTasks: [outputDirTask, wasmImportsTask],
-                    output: bridgeJs
-                ) { _, scope in
-                    let features = try Self.loadWasmFeatures(at: scope.resolve(path: wasmImportsPath))
-                    let output = try bridge.link.link(sharedMemory: features.sharedMemory)
-                    try system.writeFile(
-                        atPath: scope.resolve(path: bridgeJs).path,
-                        content: Data(output.outputJs.utf8)
-                    )
-                    try system.writeFile(
-                        atPath: scope.resolve(path: bridgeDts).path,
-                        content: Data(output.outputDts.utf8)
-                    )
-                }
-            )
-            let bridgeModulesStamp = intermediatesDir.appending(path: "bridge-js-modules.stamp")
-            packageInputs.append(
-                make.addTask(
-                    inputFiles: skeletonFiles + bridge.modules.map(\.source) + [selfPath],
-                    inputTasks: [outputDirTask, intermediatesDirTask],
-                    output: bridgeModulesStamp
-                ) { _, scope in
-                    let modulesDirectory = scope.resolve(path: bridgeModules)
-                    try system.removeItemIfExists(atPath: modulesDirectory.path)
-                    if !bridge.modules.isEmpty {
-                        try system.createDirectory(atPath: modulesDirectory.path)
-                    }
-                    for module in bridge.modules {
-                        let destination = scope.resolve(path: outputDir.appending(path: module.relativeOutputPath))
-                        try system.createDirectory(atPath: destination.deletingLastPathComponent().path)
-                        try system.syncFile(
-                            from: scope.resolve(path: module.source).path,
-                            to: destination.path
-                        )
-                    }
-                    try system.writeFile(
-                        atPath: scope.resolve(path: bridgeModulesStamp).path,
-                        content: Data()
-                    )
-                }
+                contentsOf: try planBridgeJS(
+                    make: &make,
+                    outputDirTask: outputDirTask,
+                    intermediatesDirTask: intermediatesDirTask,
+                    wasmImportsTask: wasmImportsTask
+                )
             )
         }
 
@@ -736,11 +695,15 @@ struct PackagingPlanner {
         )
     }
 
-    /// Plan the shared npm install for a directory that hosts several per-runner test
-    /// bundles as subdirectories. Node resolves `node_modules` by walking up the directory
-    /// tree, so a single install here serves every runner underneath, avoiding one install
-    /// per test target.
-    func planSharedNodeModules(make: inout MiniMake) throws -> MiniMake.TaskKey {
+    /// Plan the artifacts that several per-runner test bundles packaged as subdirectories
+    /// share.
+    ///
+    /// Node resolves `node_modules` by walking up the directory tree, so a single install
+    /// here serves every runner underneath, avoiding one install per test target. The glue
+    /// generated here describes every test target rather than the one target a runner links
+    /// in, so that test preludes - which are loaded for every runner and import it by a
+    /// fixed path - see the whole package's API.
+    func planSharedTestArtifacts(make: inout MiniMake) throws -> MiniMake.TaskKey {
         let outputDirTask = make.addTask(
             inputFiles: [selfPath],
             output: outputDir,
@@ -765,13 +728,87 @@ struct PackagingPlanner {
             inputFiles: [],
             inputTasks: []
         )
-        return planNpmInstall(
-            make: &make,
-            intermediatesDirTask: intermediatesDirTask,
-            packageJsonTask: packageJsonTask
+        var tasks = [
+            planNpmInstall(
+                make: &make,
+                intermediatesDirTask: intermediatesDirTask,
+                packageJsonTask: packageJsonTask
+            )
+        ]
+        if !skeletons.isEmpty {
+            tasks.append(
+                contentsOf: try planBridgeJS(
+                    make: &make,
+                    outputDirTask: outputDirTask,
+                    intermediatesDirTask: intermediatesDirTask,
+                    wasmImportsTask: wasmImportsTask
+                )
+            )
+        }
+        return make.addTask(
+            inputTasks: tasks,
+            output: BuildPath(phony: "shared-test-artifacts"),
+            attributes: [.phony, .silent]
         )
     }
 
+    /// Plan the tasks generating the BridgeJS glue and syncing the JavaScript modules it
+    /// imports into the output directory
+    private func planBridgeJS(
+        make: inout MiniMake,
+        outputDirTask: MiniMake.TaskKey,
+        intermediatesDirTask: MiniMake.TaskKey,
+        wasmImportsTask: MiniMake.TaskKey
+    ) throws -> [MiniMake.TaskKey] {
+        let bridge = try loadBridgeJS()
+        let skeletonFiles = skeletons.map { BuildPath(absolute: $0.source.path) }
+        let wasmImportsPath = self.wasmImportsPath
+        let bridgeJs = outputDir.appending(path: "bridge-js.js")
+        let bridgeDts = outputDir.appending(path: "bridge-js.d.ts")
+        let bridgeModules = outputDir.appending(path: "bridge-js-modules")
+        let bridgeJsTask = make.addTask(
+            inputFiles: skeletonFiles + [selfPath, wasmImportsPath],
+            inputTasks: [outputDirTask, wasmImportsTask],
+            output: bridgeJs
+        ) { _, scope in
+            let features = try Self.loadWasmFeatures(at: scope.resolve(path: wasmImportsPath))
+            let output = try bridge.link.link(sharedMemory: features.sharedMemory)
+            try system.writeFile(
+                atPath: scope.resolve(path: bridgeJs).path,
+                content: Data(output.outputJs.utf8)
+            )
+            try system.writeFile(
+                atPath: scope.resolve(path: bridgeDts).path,
+                content: Data(output.outputDts.utf8)
+            )
+        }
+        let bridgeModulesStamp = intermediatesDir.appending(path: "bridge-js-modules.stamp")
+        let bridgeModulesTask = make.addTask(
+            inputFiles: skeletonFiles + bridge.modules.map(\.source) + [selfPath],
+            inputTasks: [outputDirTask, intermediatesDirTask],
+            output: bridgeModulesStamp
+        ) { _, scope in
+            let modulesDirectory = scope.resolve(path: bridgeModules)
+            try system.removeItemIfExists(atPath: modulesDirectory.path)
+            if !bridge.modules.isEmpty {
+                try system.createDirectory(atPath: modulesDirectory.path)
+            }
+            for module in bridge.modules {
+                let destination = scope.resolve(path: outputDir.appending(path: module.relativeOutputPath))
+                try system.createDirectory(atPath: destination.deletingLastPathComponent().path)
+                try system.syncFile(
+                    from: scope.resolve(path: module.source).path,
+                    to: destination.path
+                )
+            }
+            try system.writeFile(
+                atPath: scope.resolve(path: bridgeModulesStamp).path,
+                content: Data()
+            )
+        }
+        return [bridgeJsTask, bridgeModulesTask]
+    }
+
     /// Plan the task parsing the imports of the product .wasm file
     ///
     /// NOTE: The imports are parsed from the product artifact instead of the final .wasm

Plugins/PackageToJS/Sources/PackageToJSPlugin.swift

@@ -294,12 +294,12 @@ struct PackageToJSPlugin: CommandPlugin {
                 context.pluginWorkDirectoryURL.appending(path: "PackageTests")
             }
 
-        // With multiple runners, install the test harness's npm dependencies once into the
-        // shared base directory. Each runner is packaged into a subdirectory of it, and Node
-        // resolves `node_modules` by walking up the directory tree, so one install serves
-        // them all instead of one per test target.
-        let sharesNodeModules = productArtifacts.count > 1
-        if sharesNodeModules, let firstArtifact = productArtifacts.first {
+        // With multiple runners, package what they share into the base directory once: the
+        // test harness's npm dependencies, and the glue describing every test target that
+        // preludes import by a fixed path. Each runner is packaged into a subdirectory of
+        // it.
+        let hasSharedArtifacts = productArtifacts.count > 1
+        if hasSharedArtifacts, let firstArtifact = productArtifacts.first {
             var make = MiniMake(
                 explain: testOptions.packageOptions.explain,
                 printProgress: self.printProgress
@@ -315,8 +315,8 @@ struct PackageToJSPlugin: CommandPlugin {
                     ? firstArtifact.lastPathComponent
                     : firstArtifact.lastPathComponent + ".wasm"
             )
-            let rootTask = try planner.planSharedNodeModules(make: &make)
-            print("Installing shared test dependencies...")
+            let rootTask = try planner.planSharedTestArtifacts(make: &make)
+            print("Packaging shared test artifacts...")
             try make.build(output: rootTask, scope: MiniMake.VariableScope(variables: [:]))
         }
 
@@ -341,7 +341,14 @@ struct PackageToJSPlugin: CommandPlugin {
                 options: testOptions.packageOptions,
                 context: context,
                 selfPackage: selfPackage,
-                skeletons: skeletons,
+                // Generate the glue from what this binary actually links in: the combined
+                // binary holds every test target, while a per-target runner holds one.
+                skeletons: runnerSkeletons(
+                    runnerName: runnerName,
+                    isCombinedBinary: !hasSharedArtifacts,
+                    context: context,
+                    aggregated: skeletons
+                ),
                 outputDir: outputDir,
                 wasmProductArtifact: productArtifact,
                 // If the product artifact doesn't have a .wasm extension, add it
@@ -353,7 +360,7 @@ struct PackageToJSPlugin: CommandPlugin {
             )
             let (rootTask, binDir) = try planner.planTestBuild(
                 make: &make,
-                installNodeModules: !sharesNodeModules
+                installNodeModules: !hasSharedArtifacts
             )
             cleanIfBuildGraphChanged(
                 root: rootTask,
@@ -370,21 +377,6 @@ struct PackageToJSPlugin: CommandPlugin {
             try make.build(output: rootTask, scope: scope)
             print("Packaging tests finished")
 
-            // BridgeJS emits an aggregated `bridge-js.js` (generated from every test
-            // target's skeletons, so identical across runners). Test preludes import it from
-            // the base output directory, so surface a copy there when packaging into a
-            // per-runner subdirectory. The glue imports the JavaScript modules it was linked
-            // against by a path relative to itself, so carry those over as well.
-            if outputDir != baseOutputDir {
-                for entry in ["bridge-js.js", "bridge-js-modules"] {
-                    let packaged = outputDir.appending(path: entry)
-                    guard FileManager.default.fileExists(atPath: packaged.path) else { continue }
-                    let shared = baseOutputDir.appending(path: entry)
-                    try? FileManager.default.removeItem(at: shared)
-                    try FileManager.default.copyItem(at: packaged, to: shared)
-                }
-            }
-
             if !testOptions.buildOnly {
                 let testRunner = scope.resolve(path: binDir.appending(path: "test.js"))
                 do {
@@ -408,6 +400,25 @@ struct PackageToJSPlugin: CommandPlugin {
         }
     }
 
+    /// The skeletons describing the API a single test binary exposes.
+    ///
+    /// The native build system links every test target into one binary, so it gets the
+    /// skeletons of all of them. SwiftBuild produces a `<TestTarget>-test-runner` per test
+    /// target, which only exposes that target and its dependencies.
+    private func runnerSkeletons(
+        runnerName: String,
+        isCombinedBinary: Bool,
+        context: PluginContext,
+        aggregated: [BridgeJSSkeletonInput]
+    ) -> [BridgeJSSkeletonInput] {
+        let testRunnerSuffix = "-test-runner"
+        guard !isCombinedBinary, runnerName.hasSuffix(testRunnerSuffix) else {
+            return aggregated
+        }
+        let targetName = String(runnerName.dropLast(testRunnerSuffix.count))
+        return SkeletonCollector(context: context).collectFromTest(targetName: targetName)
+    }
+
     /// Locate the test product artifact(s) to run.
     ///
     /// The native build system links all test targets into a single combined
@@ -854,16 +865,28 @@ class SkeletonCollector {
     }
 
     func collectFromTests() -> [BridgeJSSkeletonInput] {
-        let tests = context.package.targets.filter {
-            guard let target = $0 as? SwiftSourceModuleTarget else { return false }
-            return target.kind == .test
-        }
-        for test in tests {
+        for test in testTargets {
             visit(target: test, package: context.package)
         }
         return skeletons
     }
 
+    /// Collect the skeletons of a single test target and everything it links in.
+    func collectFromTest(targetName: String) -> [BridgeJSSkeletonInput] {
+        guard let test = testTargets.first(where: { $0.name == targetName }) else {
+            return []
+        }
+        visit(target: test, package: context.package)
+        return skeletons
+    }
+
+    private var testTargets: [Target] {
+        context.package.targets.filter {
+            guard let target = $0 as? SwiftSourceModuleTarget else { return false }
+            return target.kind == .test
+        }
+    }
+
     private func visit(product: Product, package: Package) {
         if visitedProducts.contains(product.id) { return }
         visitedProducts.insert(product.id)