Support SPM execution with process lifecycle management

Sources/SwiftMutationTesting/Build/BuildError.swift

@@ -1,4 +1,12 @@
 enum BuildError: Error, Equatable {
-    case compilationFailed
+    case compilationFailed(output: String)
     case xctestrunNotFound
+
+    static func == (lhs: BuildError, rhs: BuildError) -> Bool {
+        switch (lhs, rhs) {
+        case (.compilationFailed, .compilationFailed): return true
+        case (.xctestrunNotFound, .xctestrunNotFound): return true
+        default: return false
+        }
+    }
 }

Sources/SwiftMutationTesting/Build/BuildStage.swift

@@ -24,15 +24,17 @@ struct BuildStage: Sendable {
             arguments += ["-project", projectURL.path]
         }
 
-        let exitCode = try await launcher.launch(
+        let (exitCode, buildOutput) = try await launcher.launchCapturing(
             executableURL: URL(fileURLWithPath: "/usr/bin/xcodebuild"),
             arguments: arguments,
+            environment: nil,
+            additionalEnvironment: [:],
             workingDirectoryURL: sandbox.rootURL,
             timeout: timeout
         )
 
         guard exitCode == 0 else {
-            throw BuildError.compilationFailed
+            throw BuildError.compilationFailed(output: buildOutput)
         }
 
         let productsURL = derivedDataURL.appendingPathComponent("Build/Products")
@@ -59,20 +61,18 @@ struct BuildStage: Sendable {
         testTarget: String?,
         timeout: Double
     ) async throws -> BuildArtifact {
-        var arguments = ["build", "--build-tests"]
+        let arguments = ["build", "--build-tests"]
 
-        if let testTarget {
-            arguments += ["--target", testTarget]
-        }
-
-        let exitCode = try await launcher.launch(
+        let (exitCode, buildOutput) = try await launcher.launchCapturing(
             executableURL: URL(fileURLWithPath: "/usr/bin/swift"),
             arguments: arguments,
+            environment: nil,
+            additionalEnvironment: [:],
             workingDirectoryURL: sandbox.rootURL,
             timeout: timeout
         )
 
-        guard exitCode == 0 else { throw BuildError.compilationFailed }
+        guard exitCode == 0 else { throw BuildError.compilationFailed(output: buildOutput) }
 
         return BuildArtifact(
             derivedDataPath: sandbox.rootURL.appendingPathComponent(".build").path,

Sources/SwiftMutationTesting/Execution/FallbackExecutor.swift

@@ -36,24 +36,36 @@ struct FallbackExecutor: Sendable {
 
         await deps.reporter.report(.fallbackBuildStarted(filePath: file.originalPath))
 
-        guard case .xcode(let scheme, let destination) = configuration.build.projectType else {
-            try? sandbox.cleanup()
-            return await markUnviable(mutants: fileMutants, testFilesHash: testFilesHash)
-        }
-
         let artifact: BuildArtifact
-        do {
-            artifact = try await BuildStage(launcher: deps.launcher).build(
-                sandbox: sandbox,
-                scheme: scheme,
-                destination: destination,
-                timeout: configuration.build.timeout
-            )
-            await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: true))
-        } catch {
-            await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: false))
-            try? sandbox.cleanup()
-            return await markUnviable(mutants: fileMutants, testFilesHash: testFilesHash)
+        switch configuration.build.projectType {
+        case .xcode(let scheme, let destination):
+            do {
+                artifact = try await BuildStage(launcher: deps.launcher).build(
+                    sandbox: sandbox,
+                    scheme: scheme,
+                    destination: destination,
+                    timeout: configuration.build.timeout
+                )
+                await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: true))
+            } catch {
+                await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: false))
+                try? sandbox.cleanup()
+                return await markUnviable(mutants: fileMutants, testFilesHash: testFilesHash)
+            }
+
+        case .spm:
+            do {
+                artifact = try await BuildStage(launcher: deps.launcher).buildSPM(
+                    sandbox: sandbox,
+                    testTarget: configuration.build.testTarget,
+                    timeout: configuration.build.timeout
+                )
+                await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: true))
+            } catch {
+                await deps.reporter.report(.fallbackBuildFinished(filePath: file.originalPath, success: false))
+                try? sandbox.cleanup()
+                return await markUnviable(mutants: fileMutants, testFilesHash: testFilesHash)
+            }
         }
 
         let context = TestExecutionContext(