SwiftDriver: address TODO about abnormal process termination

This adds the handling for abnormal process termination on Windows.
With this, we can now track processes which exit abnormally, indicating
failure.  This was identified by the saveTemps test which now passes on
Windows.  Add an additional test case for the new message type to
differentiate the abnormal exit due to an exception from a signalled
exit which is limited to Unixish platforms.

Author: compnerd

Sources/SwiftDriver/Driver/ToolExecutionDelegate.swift

@@ -91,14 +91,15 @@ import Glibc
 
     buildRecordInfo?.jobFinished(job: job, result: result)
 
-    // FIXME: Currently, TSCBasic.Process uses NSProcess on Windows and discards
-    // the bits of the exit code used to differentiate between normal and abnormal
-    // termination.
-    #if !os(Windows)
+#if os(Windows)
+    if case .abnormal = result.exitStatus {
+      anyJobHadAbnormalExit = true
+    }
+#else
     if case .signalled = result.exitStatus {
       anyJobHadAbnormalExit = true
     }
-    #endif
+#endif
 
     switch mode {
     case .silent:
@@ -123,7 +124,13 @@ import Glibc
                                                 pid: pid).map {
           ParsableMessage(name: job.kind.rawValue, kind: .finished($0))
         }
-#if !os(Windows)
+#if os(Windows)
+      case .abnormal(let exception):
+        messages = constructAbnormalExitMessage(job: job, output: output,
+                                                exception: exception, pid: pid).map {
+          ParsableMessage(name: job.kind.rawValue, kind: .abnormal($0))
+        }
+#else
       case .signalled(let signal):
         let errorMessage = strsignal(signal).map { String(cString: $0) } ?? ""
         messages = constructJobSignalledMessages(job: job, error: errorMessage, output: output,
@@ -132,6 +139,7 @@ import Glibc
         }
 #endif
       }
+
       for message in messages {
         emit(message)
       }
@@ -265,6 +273,22 @@ private extension ToolExecutionDelegate {
     return FinishedMessage(exitStatus: Int(exitCode), output: output, pid: pid, realPid: realPid)
   }
 
+  // MARK: - Abnormal Exit
+  func constructAbnormalExitMessage(job: Job, output: String?, exception: UInt32, pid: Int) -> [AbnormalExitMessage] {
+    let result: [AbnormalExitMessage]
+    if job.kind == .compile, job.primaryInputs.count > 1 {
+      result = job.primaryInputs.map {
+        guard let quasiPid = batchJobInputQuasiPIDMap[(job, $0)] else {
+          fatalError("Parsable-Output batch sub-job abnormal exit with no matching started message: \(job.description): \($0.file.description)")
+        }
+        return AbnormalExitMessage(pid: quasiPid, realPid: pid, output: output, exception: exception)
+      }
+    } else {
+      result = [AbnormalExitMessage(pid: pid, realPid: pid, output: output, exception: exception)]
+    }
+    return result
+  }
+
   // MARK: - Job Signalled
   func constructJobSignalledMessages(job: Job, error: String, output: String?,
                                      signal: Int32, pid: Int) -> [SignalledMessage] {

Sources/SwiftDriver/Execution/DriverExecutor.swift

@@ -123,10 +123,13 @@ extension DriverExecutor {
     switch exitStatus {
       case .terminated(let code):
         returnCode = Int(code)
-      #if !os(Windows)
+#if os(Windows)
+      case .abnormal(let exception):
+        returnCode = Int(exception)
+#else
       case .signalled(let signal):
         returnCode = Int(signal)
-      #endif
+#endif
     }
     return returnCode
   }

Sources/SwiftDriver/Execution/ParsableOutput.swift

@@ -16,6 +16,7 @@ import Foundation
   public enum Kind {
     case began(BeganMessage)
     case finished(FinishedMessage)
+    case abnormal(AbnormalExitMessage)
     case signalled(SignalledMessage)
     case skipped(SkippedMessage)
   }
@@ -133,6 +134,27 @@ import Foundation
   }
 }
 
+@_spi(Testing) public struct AbnormalExitMessage: Encodable {
+  let pid: Int
+  let process: ActualProcess
+  let output: String?
+  let exception: UInt32
+
+  public init(pid: Int, realPid: Int, output: String?, exception: UInt32) {
+    self.pid = pid
+    self.process = ActualProcess(realPid: realPid)
+    self.output = output
+    self.exception = exception
+  }
+
+  private enum CodingKeys: String, CodingKey {
+    case pid
+    case process
+    case output
+    case exception
+  }
+}
+
 @_spi(Testing) public struct SignalledMessage: Encodable {
   let pid: Int
   let process: ActualProcess
@@ -174,6 +196,9 @@ import Foundation
     case .finished(let msg):
       try container.encode("finished", forKey: .kind)
       try msg.encode(to: encoder)
+    case .abnormal(let msg):
+      try container.encode("abnormal-exit", forKey: .kind)
+      try msg.encode(to: encoder)
     case .signalled(let msg):
       try container.encode("signalled", forKey: .kind)
       try msg.encode(to: encoder)

Sources/SwiftDriver/Jobs/PrebuiltModulesJob.swift

@@ -122,7 +122,10 @@ fileprivate class ModuleCompileDelegate: JobExecutionDelegate {
           stderrStream.flush()
         }
       }
-#if !os(Windows)
+#if os(Windows)
+    case .abnormal(let exception):
+      diagnosticsEngine.emit(.remark("\(job.moduleName) exception: \(exception)"))
+#else
     case .signalled:
       diagnosticsEngine.emit(.remark("\(job.moduleName) interrupted"))
 #endif

Sources/SwiftDriverExecution/MultiJobExecutor.swift

@@ -211,10 +211,13 @@ public final class MultiJobExecutor {
       switch (result.exitStatus, continueBuildingAfterErrors) {
       case (.terminated(let code), false) where code != EXIT_SUCCESS:
          isBuildCancelled = true
-       #if !os(Windows)
+#if os(Windows)
+      case (.abnormal, false):
+         isBuildCancelled = true
+#else
        case (.signalled, _):
          isBuildCancelled = true
-       #endif
+#endif
       default:
         break
       }
@@ -614,6 +617,8 @@ class ExecuteJobRule: LLBuildRule {
           if !job.kind.isCompile || code != EXIT_FAILURE {
             context.diagnosticsEngine.emit(.error_command_failed(kind: job.kind, code: code))
           }
+        case let .abnormal(exception):
+          context.diagnosticsEngine.emit(.error_command_exception(kind: job.kind, exception: exception))
 #if !os(Windows)
         case let .signalled(signal):
           // An interrupt of an individual compiler job means it was deliberatly cancelled,
@@ -667,4 +672,8 @@ private extension TSCBasic.Diagnostic.Message {
   static func error_command_signalled(kind: Job.Kind, signal: Int32) -> TSCBasic.Diagnostic.Message {
     .error("\(kind.rawValue) command failed due to signal \(signal) (use -v to see invocation)")
   }
+
+  static func error_command_exception(kind: Job.Kind, exception: UInt32) -> TSCBasic.Diagnostic.Message {
+    .error("\(kind.rawValue) command failed due to exception \(exception) (use -v to see invocation)")
+  }
 }

Tests/SwiftDriverTests/ParsableMessageTests.swift

@@ -118,6 +118,25 @@ final class ParsableMessageTests: XCTestCase {
     """)
   }
 
+  func testAbnormalExitMessage() throws {
+    let exit = AbnormalExitMessage(pid: 1024, realPid: 1024, output: nil, exception: 0x8000_0003)
+    let message = ParsableMessage(name: "compile", kind: .abnormal(exit))
+    let encoded = try message.toJSON()
+    let string = String(data: encoded, encoding: .utf8)!
+
+    XCTAssertEqual(string, """
+    {
+      "exception" : 2147483651,
+      "kind" : "abnormal-exit",
+      "name" : "compile",
+      "pid" : 1024,
+      "process" : {
+        "real_pid" : 1024
+      }
+    }
+    """)
+  }
+
   func testBeganBatchMessages() throws {
     do {
       try withTemporaryDirectory { path in