Add LLDB debugger support to swift-test command

Fixtures/Miscellaneous/TestDebugging/Package.swift

@@ -0,0 +1,10 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "TestDebugging",
+    targets: [
+        .target(name: "TestDebugging"),
+        .testTarget(name: "TestDebuggingTests", dependencies: ["TestDebugging"]),
+    ]
+)

Fixtures/Miscellaneous/TestDebugging/Sources/TestDebugging/TestDebugging.swift

@@ -0,0 +1,23 @@
+public struct Calculator {
+    public init() {}
+
+    public func add(_ a: Int, _ b: Int) -> Int {
+        return a + b
+    }
+
+    public func subtract(_ a: Int, _ b: Int) -> Int {
+        return a - b
+    }
+
+    public func multiply(_ a: Int, _ b: Int) -> Int {
+        return a * b
+    }
+
+    public func divide(_ a: Int, _ b: Int) -> Int {
+        return a / b
+    }
+
+    public func purposelyFail() -> Bool {
+        return false
+    }
+}

Fixtures/Miscellaneous/TestDebugging/Tests/TestDebuggingTests/TestDebuggingTests.swift

@@ -0,0 +1,34 @@
+import XCTest
+import Testing
+@testable import TestDebugging
+
+// MARK: - XCTest Suite
+final class XCTestCalculatorTests: XCTestCase {
+
+    func testAdditionPasses() {
+        let calculator = Calculator()
+        let result = calculator.add(2, 3)
+        XCTAssertEqual(result, 5, "Addition should return 5 for 2 + 3")
+    }
+
+    func testSubtractionFails() {
+        let calculator = Calculator()
+        let result = calculator.subtract(5, 3)
+        XCTAssertEqual(result, 3, "This test is designed to fail - subtraction 5 - 3 should equal 2, not 3")
+    }
+}
+
+// MARK: - Swift Testing Suite
+@Test("Calculator Addition Works Correctly")
+func calculatorAdditionPasses() {
+    let calculator = Calculator()
+    let result = calculator.add(4, 6)
+    #expect(result == 10, "Addition should return 10 for 4 + 6")
+}
+
+@Test("Calculator Boolean Check Fails")
+func calculatorBooleanFails() {
+    let calculator = Calculator()
+    let result = calculator.purposelyFail()
+    #expect(result == true, "This test is designed to fail - purposelyFail() should return false, not true")
+}

Fixtures/Miscellaneous/TestDebuggingMultiProduct/Package.swift

@@ -0,0 +1,12 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "TestDebuggingMultiProduct",
+    targets: [
+        .target(name: "LibA"),
+        .target(name: "LibB"),
+        .testTarget(name: "LibATests", dependencies: ["LibA"]),
+        .testTarget(name: "LibBTests", dependencies: ["LibB"]),
+    ]
+)

Fixtures/Miscellaneous/TestDebuggingMultiProduct/Sources/LibA/LibA.swift

@@ -0,0 +1,7 @@
+public struct LibA {
+    public init() {}
+
+    public func greet() -> String {
+        return "Hello from LibA"
+    }
+}

Fixtures/Miscellaneous/TestDebuggingMultiProduct/Sources/LibB/LibB.swift

@@ -0,0 +1,7 @@
+public struct LibB {
+    public init() {}
+
+    public func greet() -> String {
+        return "Hello from LibB"
+    }
+}

Fixtures/Miscellaneous/TestDebuggingMultiProduct/Tests/LibATests/LibATests.swift

@@ -0,0 +1,16 @@
+import XCTest
+import Testing
+@testable import LibA
+
+final class LibAXCTests: XCTestCase {
+    func testGreet() {
+        let lib = LibA()
+        XCTAssertEqual(lib.greet(), "Hello from LibA")
+    }
+}
+
+@Test("LibA greeting works")
+func libAGreeting() {
+    let lib = LibA()
+    #expect(lib.greet() == "Hello from LibA")
+}

Fixtures/Miscellaneous/TestDebuggingMultiProduct/Tests/LibBTests/LibBTests.swift

@@ -0,0 +1,16 @@
+import XCTest
+import Testing
+@testable import LibB
+
+final class LibBXCTests: XCTestCase {
+    func testGreet() {
+        let lib = LibB()
+        XCTAssertEqual(lib.greet(), "Hello from LibB")
+    }
+}
+
+@Test("LibB greeting works")
+func libBGreeting() {
+    let lib = LibB()
+    #expect(lib.greet() == "Hello from LibB")
+}

Sources/Commands/CMakeLists.txt

@@ -54,6 +54,7 @@ add_library(Commands
   Utilities/DOTManifestSerializer.swift
   Utilities/MermaidPackageSerializer.swift
   Utilities/MultiRootSupport.swift
+  Utilities/NonEmpty.swift
   Utilities/PlainTextEncoder.swift
   Utilities/PluginDelegate.swift
   Utilities/RefactoringSupport.swift

Sources/Commands/SwiftRunCommand.swift

@@ -19,7 +19,6 @@ import PackageModel
 import SPMBuildCore
 
 import enum TSCBasic.ProcessEnv
-import func TSCBasic.exec
 
 import enum TSCUtility.Diagnostics
 
@@ -153,7 +152,8 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
                 fileSystem: swiftCommandState.fileSystem,
                 executablePath: interpreterPath,
                 originalWorkingDirectory: swiftCommandState.originalWorkingDirectory,
-                arguments: arguments
+                arguments: arguments,
+                observabilityScope: swiftCommandState.observabilityScope
             )
 
         case .debugger:
@@ -183,12 +183,17 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
                         fileSystem: swiftCommandState.fileSystem,
                         executablePath: debuggerPath,
                         originalWorkingDirectory: swiftCommandState.originalWorkingDirectory,
-                        arguments: debugger.extraCLIOptions + [productAbsolutePath.pathString] + options.arguments
+                        arguments: debugger.extraCLIOptions + [productAbsolutePath.pathString] + options.arguments,
+                        observabilityScope: swiftCommandState.observabilityScope
                     )
                 } else {
                     let pathRelativeToWorkingDirectory = productAbsolutePath.relative(to: swiftCommandState.originalWorkingDirectory)
                     let lldbPath = try swiftCommandState.getTargetToolchain().getLLDB()
-                    try exec(path: lldbPath.pathString, args: ["--", pathRelativeToWorkingDirectory.pathString] + options.arguments)
+                    try safeExec(
+                        path: lldbPath.pathString,
+                        args: ["--", pathRelativeToWorkingDirectory.pathString] + options.arguments,
+                        observabilityScope: swiftCommandState.observabilityScope
+                    )
                 }
             } catch let error as RunError {
                 swiftCommandState.observabilityScope.emit(error)
@@ -207,7 +212,8 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
                     fileSystem: swiftCommandState.fileSystem,
                     executablePath: swiftInterpreterPath,
                     originalWorkingDirectory: swiftCommandState.originalWorkingDirectory,
-                    arguments: arguments
+                    arguments: arguments,
+                    observabilityScope: swiftCommandState.observabilityScope
                 )
                 return
             }
@@ -245,7 +251,8 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
                     fileSystem: swiftCommandState.fileSystem,
                     executablePath: runnerPath,
                     originalWorkingDirectory: swiftCommandState.originalWorkingDirectory,
-                    arguments: arguments
+                    arguments: arguments,
+                    observabilityScope: swiftCommandState.observabilityScope
                 )
             } catch Diagnostics.fatalError {
                 throw ExitCode.failure
@@ -294,7 +301,8 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
         fileSystem: FileSystem,
         executablePath: AbsolutePath,
         originalWorkingDirectory: AbsolutePath,
-        arguments: [String]
+        arguments: [String],
+        observabilityScope: ObservabilityScope
     ) throws {
         // Make sure we are running from the original working directory.
         let cwd: AbsolutePath? = fileSystem.currentWorkingDirectory
@@ -303,7 +311,7 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
         }
 
         let pathRelativeToWorkingDirectory = executablePath.relative(to: originalWorkingDirectory)
-        try execute(path: executablePath.pathString, args: [pathRelativeToWorkingDirectory.pathString] + arguments)
+        try safeExec(path: executablePath.pathString, args: [pathRelativeToWorkingDirectory.pathString] + arguments, observabilityScope: observabilityScope)
     }
 
     /// Determines if a path points to a valid swift file.
@@ -326,41 +334,6 @@ public struct SwiftRunCommand: AsyncSwiftCommand {
         return fileSystem.isFile(absolutePath)
     }
 
-    /// A safe wrapper of TSCBasic.exec.
-    private func execute(path: String, args: [String]) throws -> Never {
-        #if !os(Windows)
-        // Dispatch will disable almost all asynchronous signals on its worker threads, and this is called from `async`
-        // context. To correctly `exec` a freshly built binary, we will need to:
-        // 1. reset the signal masks
-        for i in 1..<NSIG {
-            signal(i, SIG_DFL)
-        }
-        var sig_set_all = sigset_t()
-        sigfillset(&sig_set_all)
-        sigprocmask(SIG_UNBLOCK, &sig_set_all, nil)
-
-        #if os(FreeBSD) || os(OpenBSD)
-        #if os(FreeBSD)
-        pthread_suspend_all_np()
-        #endif
-        closefrom(3)
-        #else
-        #if os(Android)
-        let number_fds = Int32(sysconf(_SC_OPEN_MAX))
-        #else
-        let number_fds = getdtablesize()
-        #endif /* os(Android) */
-
-        // 2. set to close all file descriptors on exec
-        for i in 3..<number_fds {
-            _ = fcntl(i, F_SETFD, FD_CLOEXEC)
-        }
-        #endif /* os(FreeBSD) || os(OpenBSD) */
-        #endif
-
-        try TSCBasic.exec(path: path, args: args)
-    }
-
     public init() {}
 }