[5.6] Fix SIGINT handling during swift run (Cherry-pick of #4224, #4235, #4250) (#4231)

* Fix SIGINT handling during `swift run` (#4224)
* Fix SIGINT handling during `swift run`
* Create a safe wrapper of TSCBasic.exec
* add test fixture for handling SIGINT on "swift run" (#4250)

Co-authored-by: tomer doron <tomer@apple.com>

rdar://90574791

Author: kkebo

Fixtures/Miscellaneous/SwiftRun/Package.swift

@@ -0,0 +1,12 @@
+// swift-tools-version: 5.6
+import PackageDescription
+
+let package = Package(
+    name: "TestableExe",
+    targets: [
+        .executableTarget(
+            name: "Test",
+            path: "."
+        ),
+    ]
+)

Fixtures/Miscellaneous/SwiftRun/main.swift

@@ -0,0 +1 @@
+print("done")

Sources/Commands/SwiftTool.swift

@@ -255,6 +255,17 @@ extension SwiftCommand {
     public static var _errorLabel: String { "error" }
 }
 
+/// A safe wrapper of TSCBasic.exec.
+func exec(path: String, args: [String]) throws -> Never {
+    #if !os(Windows)
+    // On platforms other than Windows, signal(SIGINT, SIG_IGN) is used for handling SIGINT by DispatchSourceSignal,
+    // but this process is about to be replaced by exec, so SIG_IGN must be returned to default.
+    signal(SIGINT, SIG_DFL)
+    #endif
+
+    try TSCBasic.exec(path: path, args: args)
+}
+
 public class SwiftTool {
     #if os(Windows)
     // unfortunately this is needed for C callback handlers used by Windows shutdown handler

Tests/FunctionalTests/MiscellaneousTests.swift

@@ -8,6 +8,7 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
+import Basics
 import XCTest
 import SPMTestSupport
 import TSCBasic
@@ -398,6 +399,86 @@ class MiscellaneousTestCase: XCTestCase {
       #endif
     }
 
+    func testSwiftRunSIGNINT() throws {
+        try fixture(name: "Miscellaneous/SwiftRun") { fixturePath in
+            let mainFilePath = fixturePath.appending(component: "main.swift")
+            try localFileSystem.removeFileTree(mainFilePath)
+            try localFileSystem.writeFileContents(mainFilePath) {
+                """
+                import Foundation
+
+                print("sleeping")
+                fflush(stdout)
+
+                sleep(10)
+                print("done")
+                """
+            }
+
+            let sync = DispatchGroup()
+            let outputHandler = OutputHandler(sync: sync)
+            let process = Process(
+                arguments: [SwiftPMProduct.SwiftRun.path.pathString, "--package-path", fixturePath.pathString],
+                outputRedirection: .stream(stdout: outputHandler.handle(bytes:), stderr: outputHandler.handle(bytes:))
+            )
+
+            sync.enter()
+            try process.launch()
+
+            // wait for the process to start
+            if case .timedOut = sync.wait(timeout: .now() + 60) {
+                return XCTFail("timeout waiting for process to start")
+            }
+
+            // interrupt the process
+            print("interrupting")
+            process.signal(SIGINT)
+
+            // check for interrupt result
+            let result = try process.waitUntilExit()
+            XCTAssertEqual(result.exitStatus, .signalled(signal: 2))
+        }
+
+        class OutputHandler {
+            let sync: DispatchGroup
+            var state = State.idle
+            let lock = Lock()
+
+            init(sync: DispatchGroup) {
+                self.sync = sync
+            }
+
+            func handle(bytes: [UInt8]) {
+                guard let output = String(bytes: bytes, encoding: .utf8) else {
+                    return
+                }
+                self.lock.withLock {
+                    switch self.state {
+                    case .idle:
+                        self.state = .buffering(output)
+                    case .buffering(let buffer):
+                        print(output, terminator: "")
+                        let newBuffer = buffer + output
+                        if newBuffer.contains("sleeping") {
+                            self.state = .done
+                            self.sync.leave()
+                        } else {
+                            self.state = .buffering(newBuffer)
+                        }
+                    case .done:
+                        break //noop
+                    }
+                }
+            }
+
+            enum State {
+                case idle
+                case buffering(String)
+                case done
+            }
+        }
+    }
+
     func testReportingErrorFromGitCommand() throws {
         fixture(name: "Miscellaneous/MissingDependency") { prefix in
             // This fixture has a setup that is intentionally missing a local