Add a C (@_cdecl) API for the driver's getSingleFrontendInvocationFromDriverArguments

This will enable non-Swift clients to query this utility as an alternative to the legacy C++ driver's equivalent.

Author: artemcm

Package.swift

@@ -69,7 +69,7 @@ let package = Package(
     /// Driver tests.
     .testTarget(
       name: "SwiftDriverTests",
-      dependencies: ["SwiftDriver", "SwiftDriverExecution", "TestUtilities"]),
+      dependencies: ["SwiftDriver", "SwiftDriverExecution", "TestUtilities", "ToolingTestShim"]),
 
     /// IncrementalImport tests
     .testTarget(
@@ -93,6 +93,11 @@ let package = Package(
       dependencies: ["SwiftDriver", "SwiftDriverExecution"],
       path: "Tests/TestUtilities"),
 
+    .target(
+      name: "ToolingTestShim",
+      dependencies: ["SwiftDriver"],
+      path: "Tests/ToolingTestShim"),
+
     /// The options library.
     .target(
       name: "SwiftOptions",
@@ -120,7 +125,7 @@ let package = Package(
       ],
       exclude: ["CMakeLists.txt"]),
 
-    /// The help executable.
+    /// Build SDK Interfaces tool executable.
     .executableTarget(
       name: "swift-build-sdk-interfaces",
       dependencies: ["SwiftDriver", "SwiftDriverExecution"],

Sources/SwiftDriver/SwiftScan/SwiftScan.swift

@@ -787,8 +787,8 @@ private extension swiftscan_functions_t {
 
 // TODO: Move to TSC?
 /// Perform an  `action` passing it a `const char **` constructed out of `[String]`
-func withArrayOfCStrings<T>(_ strings: [String],
-                            _ action:  (UnsafeMutablePointer<UnsafePointer<Int8>?>?) -> T) -> T
+@_spi(Testing) public func withArrayOfCStrings<T>(_ strings: [String],
+                                                  _ action:  (UnsafeMutablePointer<UnsafePointer<Int8>?>?) -> T) -> T
 {
   let cstrings = strings.map { strdup($0) } + [nil]
   let unsafeCStrings = cstrings.map { UnsafePointer($0) }

Sources/SwiftDriver/ToolingInterface/ToolingUtil.swift

@@ -17,24 +17,96 @@ import enum TSCBasic.ProcessEnv
 import var TSCBasic.localFileSystem
 import SwiftOptions
 
+//typedef enum {
+//  SWIFTDRIVER_TOOLING_DIAGNOSTIC_ERROR = 0,
+//  SWIFTDRIVER_TOOLING_DIAGNOSTIC_WARNING = 1,
+//  SWIFTDRIVER_TOOLING_DIAGNOSTIC_REMARK = 2,
+//  SWIFTDRIVER_TOOLING_DIAGNOSTIC_NOTE = 3
+//} swiftdriver_tooling_diagnostic_kind;
+public let SWIFTDRIVER_TOOLING_DIAGNOSTIC_ERROR: CInt = 0;
+public let SWIFTDRIVER_TOOLING_DIAGNOSTIC_WARNING: CInt = 1;
+public let SWIFTDRIVER_TOOLING_DIAGNOSTIC_REMARK: CInt = 2;
+public let SWIFTDRIVER_TOOLING_DIAGNOSTIC_NOTE: CInt = 3;
+
+@_cdecl("swift_getSingleFrontendInvocationFromDriverArgumentsV2")
+public func getSingleFrontendInvocationFromDriverArgumentsV2(driverPath: UnsafePointer<CChar>,
+                                                             argListCount: CInt,
+                                                             argList: UnsafePointer<UnsafePointer<CChar>?>,
+                                                             action: @convention(c) (CInt, UnsafePointer<UnsafePointer<CChar>?>) -> Bool,
+                                                             diagnosticCallback: @convention(c) (CInt, UnsafePointer<CChar>) -> Void,
+                                                             forceNoOutputs: Bool = false) -> Bool {
+  // Bridge the driver path argument
+  let bridgedDriverPath = String(cString: driverPath)
+
+  // Bridge the argv equivalent
+  let argListBufferPtr = UnsafeBufferPointer<UnsafePointer<CChar>?>(start: argList, count: Int(argListCount))
+  let bridgedArgList = [bridgedDriverPath] + argListBufferPtr.map { String(cString: $0!) }
+
+  // Bridge the action callback
+  let bridgedAction: ([String]) -> Bool = { args in
+    return withArrayOfCStrings(args) {
+      return action(CInt(args.count), $0!)
+    }
+  }
+
+  // Bridge the diagnostic callback
+  let bridgedDiagnosticCallback: (CInt, String) -> Void = { diagKind, message in
+    diagnosticCallback(diagKind, message)
+  }
+
+  var diagnostics: [Diagnostic] = []
+  let result = getSingleFrontendInvocationFromDriverArgumentsV2(driverPath: bridgedDriverPath,
+                                                                argList: bridgedArgList,
+                                                                action: bridgedAction,
+                                                                diagnostics: &diagnostics,
+                                                                diagnosticCallback: bridgedDiagnosticCallback,
+                                                                forceNoOutputs: forceNoOutputs)
+  return result
+}
+
 /// Generates the list of arguments that would be passed to the compiler
-/// frontend from the given driver arguments.
+/// frontend from the given driver arguments, for a single-compiler-invocation
+/// context.
 ///
-/// \param ArgList The driver arguments (i.e. normal arguments for \c swiftc).
-/// \param ForceNoOutputs If true, override the output mode to "-typecheck" and
+/// \param driverPath the driver executable path
+/// \param argList The driver arguments (i.e. normal arguments for \c swiftc).
+/// \param diagnostics Contains the diagnostics emitted by the driver
+/// \param action invokes a user-provided action on the resulting frontend invocation command
+/// \param forceNoOutputs If true, override the output mode to "-typecheck" and
 /// produce no outputs. For example, this disables "-emit-module" and "-c" and
 /// prevents the creation of temporary files.
-/// \param outputFrontendArgs Contains the resulting frontend invocation command
-/// \param emittedDiagnostics Contains the diagnostics emitted by the driver
 ///
 /// \returns true on error
 ///
 /// \note This function is not intended to create invocations which are
 /// suitable for use in REPL or immediate modes.
-public func getSingleFrontendInvocationFromDriverArguments(argList: [String],
-                                                           outputFrontendArgs: inout [String],
-                                                           emittedDiagnostics: inout [Diagnostic],
-                                                           forceNoOutputs: Bool = false) -> Bool {
+public func getSingleFrontendInvocationFromDriverArgumentsV2(driverPath: String,
+                                                             argList: [String],
+                                                             action: ([String]) -> Bool,
+                                                             diagnostics: inout [Diagnostic],
+                                                             diagnosticCallback:  @escaping (CInt, String) -> Void,
+                                                             forceNoOutputs: Bool = false) -> Bool {
+  /// Handler for emitting diagnostics to tooling clients.
+  let toolingDiagnosticsHandler: DiagnosticsEngine.DiagnosticsHandler = { diagnostic in
+    let diagnosticKind: CInt
+    switch diagnostic.message.behavior {
+    case .error:
+      diagnosticKind = SWIFTDRIVER_TOOLING_DIAGNOSTIC_ERROR
+    case .warning:
+      diagnosticKind = SWIFTDRIVER_TOOLING_DIAGNOSTIC_WARNING
+    case .note:
+      diagnosticKind = SWIFTDRIVER_TOOLING_DIAGNOSTIC_NOTE
+    case .remark:
+      diagnosticKind = SWIFTDRIVER_TOOLING_DIAGNOSTIC_REMARK
+    default:
+      diagnosticKind = SWIFTDRIVER_TOOLING_DIAGNOSTIC_ERROR
+    }
+    diagnosticCallback(diagnosticKind, diagnostic.message.text)
+  }
+  let diagnosticsEngine = DiagnosticsEngine(handlers: [toolingDiagnosticsHandler])
+  defer { diagnostics = diagnosticsEngine.diagnostics }
+
+  var singleFrontendTaskCommand: [String] = []
   var args: [String] = []
   args.append(contentsOf: argList)
 
@@ -55,13 +127,10 @@ public func getSingleFrontendInvocationFromDriverArguments(argList: [String],
   args.append("-driver-filelist-threshold");
   args.append(String(Int.max));
 
-  let diagnosticsEngine = DiagnosticsEngine()
-  defer { emittedDiagnostics = diagnosticsEngine.diagnostics }
-
   do {
-    args = try ["swiftc"] + Driver.expandResponseFiles(args,
-                                                       fileSystem: localFileSystem,
-                                                       diagnosticsEngine: diagnosticsEngine)
+    args = try [driverPath] + Driver.expandResponseFiles(args,
+                                                         fileSystem: localFileSystem,
+                                                         diagnosticsEngine: diagnosticsEngine)
 
     let optionTable = OptionTable()
     var parsedOptions = try optionTable.parse(Array(args), for: .batch, delayThrows: true)
@@ -84,7 +153,6 @@ public func getSingleFrontendInvocationFromDriverArguments(argList: [String],
       return true
     }
 
-
     let buildPlan = try driver.planBuild()
     if diagnosticsEngine.hasErrors {
       return true
@@ -98,12 +166,12 @@ public func getSingleFrontendInvocationFromDriverArguments(argList: [String],
       diagnosticsEngine.emit(.error_expected_frontend_command())
       return true
     }
-    outputFrontendArgs = try executor.description(of: compileJob,
-                                                  forceResponseFiles: false).components(separatedBy: " ")
+    singleFrontendTaskCommand = try executor.description(of: compileJob,
+                                                         forceResponseFiles: false).components(separatedBy: " ")
   } catch {
     print("Unexpected error: \(error).")
     return true
   }
 
-  return false
+  return action(singleFrontendTaskCommand)
 }