Merge pull request #30 from sjavora/signalled-message

[Parseable output] Implement SignalledMessage

Author: DougGregor

Sources/SwiftDriver/Driver/ToolExecutionDelegate.swift

@@ -11,6 +11,17 @@
 //===----------------------------------------------------------------------===//
 import TSCBasic
 
+#if canImport(Darwin)
+import Darwin.C
+#elseif os(Windows)
+import MSVCRT
+import WinSDK
+#elseif canImport(Glibc)
+import Glibc
+#else
+#error("Missing libc or equivalent")
+#endif
+
 /// Delegate for printing execution information on the command-line.
 public struct ToolExecutionDelegate: JobExecutorDelegate {
   public enum Mode {
@@ -58,18 +69,20 @@ public struct ToolExecutionDelegate: JobExecutorDelegate {
       }
 
     case .parsableOutput:
+      let output = (try? result.utf8Output() + result.utf8stderrOutput()).flatMap { $0.isEmpty ? nil : $0 }
+      let message: ParsableMessage
+
       switch result.exitStatus {
       case .terminated(let code):
-        let output = (try? result.utf8Output() + result.utf8stderrOutput()) ?? ""
-        let finishedMessage = FinishedMessage(exitStatus: Int(code), pid: pid, output: output.isEmpty ? nil : output)
-        let message = ParsableMessage.finishedMessage(name: job.kind.rawValue, msg: finishedMessage)
-        emit(message)
+        let finishedMessage = FinishedMessage(exitStatus: Int(code), pid: pid, output: output)
+        message = ParsableMessage.finishedMessage(name: job.kind.rawValue, msg: finishedMessage)
 
-      case .signalled:
-        // FIXME: Implement this.
-        break
+      case .signalled(let signal):
+        let errorMessage = strsignal(signal).map { String(cString: $0) } ?? ""
+        let signalledMessage = SignalledMessage(pid: pid, output: output, errorMessage: errorMessage, signal: Int(signal))
+        message = ParsableMessage.signalledMessage(name: job.kind.rawValue, msg: signalledMessage)
       }
-
+      emit(message)
     }
   }
 

Sources/SwiftDriver/Execution/ParsableOutput.swift

@@ -16,7 +16,7 @@ public struct ParsableMessage {
   public enum Kind {
     case began(BeganMessage)
     case finished(FinishedMessage)
-    case signalled
+    case signalled(SignalledMessage)
     case skipped
   }
 
@@ -37,6 +37,13 @@ public struct ParsableMessage {
     return ParsableMessage(name: name, kind: .finished(msg))
   }
 
+  public static func signalledMessage(
+    name: String,
+    msg: SignalledMessage
+  ) -> ParsableMessage {
+    return ParsableMessage(name: name, kind: .signalled(msg))
+  }
+
   public func toJSON() throws -> Data {
     let encoder = JSONEncoder()
     encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
@@ -108,6 +115,27 @@ public struct FinishedMessage: Encodable {
   }
 }
 
+public struct SignalledMessage: Encodable {
+  let pid: Int
+  let output: String?
+  let errorMessage: String
+  let signal: Int
+
+  public init(pid: Int, output: String?, errorMessage: String, signal: Int) {
+    self.pid = pid
+    self.output = output
+    self.errorMessage = errorMessage
+    self.signal = signal
+  }
+
+  private enum CodingKeys: String, CodingKey {
+    case pid
+    case output
+    case errorMessage = "error-message"
+    case signal
+  }
+}
+
 extension ParsableMessage: Encodable {
   enum CodingKeys: CodingKey {
     case name
@@ -125,8 +153,9 @@ extension ParsableMessage: Encodable {
     case .finished(let msg):
       try container.encode("finished", forKey: .kind)
       try msg.encode(to: encoder)
-    case .signalled:
-      break
+    case .signalled(let msg):
+      try container.encode("signalled", forKey: .kind)
+      try msg.encode(to: encoder)
     case .skipped:
       break
     }

Tests/SwiftDriverTests/ParsableMessageTests.swift

@@ -70,4 +70,22 @@ final class ParsableMessageTests: XCTestCase {
     }
     """)
   }
+
+    func testSignalledMessage() throws {
+      let msg = SignalledMessage(pid: 2, output: "sig", errorMessage: "err", signal: 3)
+      let signalledMessage = ParsableMessage.signalledMessage(name: "compile", msg: msg)
+      let encoded = try signalledMessage.toJSON()
+      let string = String(data: encoded, encoding: .utf8)!
+
+      XCTAssertEqual(string, """
+      {
+        "error-message" : "err",
+        "kind" : "signalled",
+        "name" : "compile",
+        "output" : "sig",
+        "pid" : 2,
+        "signal" : 3
+      }
+      """)
+    }
 }