Add 'resolveArgumentList' API which contains original command-line if a response file is used

Author: artemcm

Sources/SwiftDriver/Execution/ArgsResolver.swift

@@ -26,6 +26,11 @@ public enum ResponseFileHandling {
   case heuristic
 }
 
+public enum ResolvedCommandLine {
+  case plain([String])
+  case usingResponseFile(resolved: [String], responseFileContents: [String])
+}
+
 /// Resolver for a job's argument template.
 public final class ArgsResolver {
   /// The map of virtual path to the actual path.
@@ -76,6 +81,18 @@ public final class ArgsResolver {
     return (arguments, usingResponseFile)
   }
 
+  public func resolveArgumentList(for job: Job, useResponseFiles: ResponseFileHandling = .heuristic)
+  throws -> ResolvedCommandLine {
+    let tool = try resolve(.path(job.tool))
+    let resolvedArguments = [tool] + (try resolveArgumentList(for: job.commandLine))
+    var actualArguments = resolvedArguments
+    let usingResponseFile = try createResponseFileIfNeeded(for: job, resolvedArguments: &actualArguments,
+                                                           useResponseFiles: useResponseFiles)
+    return usingResponseFile ? .usingResponseFile(resolved: actualArguments,
+                                                  responseFileContents: resolvedArguments)
+                             : .plain(actualArguments)
+  }
+
   public func resolveArgumentList(for commandLine: [Job.ArgTemplate]) throws -> [String] {
     return try commandLine.map { try resolve($0) }
   }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -1840,37 +1840,38 @@ final class SwiftDriverTests: XCTestCase {
       }
     }
 
-    // No response file
+    // Response file query with full command-line API
     do {
-      var driver = try Driver(args: ["swift"] + ["foo.swift"])
+      let source = try AbsolutePath(validating: "/foo.swift")
+      var driver = try Driver(args: ["swift"] + [source.nativePathString(escaped: false)])
       let jobs = try driver.planBuild()
       XCTAssertEqual(jobs.count, 1)
       XCTAssertEqual(jobs[0].kind, .interpret)
       let interpretJob = jobs[0]
       let resolver = try ArgsResolver(fileSystem: localFileSystem)
-      let resolvedArgs: [String] = try resolver.resolveArgumentList(for: interpretJob)
-      XCTAssertFalse(resolvedArgs.contains { $0.hasPrefix("@") })
+      let resolved: ResolvedCommandLine = try resolver.resolveArgumentList(for: interpretJob, useResponseFiles: .forced)
+      guard case .usingResponseFile(resolved: let resolvedArgs, responseFileContents: let contents) = resolved else {
+          XCTFail("Argument wasn't a response file")
+        return
+      }
+      XCTAssertEqual(resolvedArgs.count, 3)
+      XCTAssertEqual(resolvedArgs[1], "-frontend")
+      XCTAssertEqual(resolvedArgs[2].first, "@")
+
+      XCTAssertTrue(contents.contains(subsequence: ["-frontend", "-interpret"]))
+      XCTAssertTrue(contents.contains(subsequence: ["-module-name", "foo"]))
     }
-  }
 
-  func testResponseFileDeterministicNaming() throws {
-#if !os(macOS)
-    try XCTSkipIf(true, "Test assumes macOS response file quoting behavior")
-#endif
+    // No response file
     do {
-      let testJob = Job(moduleName: "Foo",
-                        kind: .compile,
-                        tool: .init(path: try AbsolutePath(validating: "/swiftc"), supportsResponseFiles: true),
-                        commandLine: (1...20000).map { .flag("-DTEST_\($0)") },
-                        inputs: [],
-                        primaryInputs: [],
-                        outputs: [])
+      var driver = try Driver(args: ["swift"] + ["foo.swift"])
+      let jobs = try driver.planBuild()
+      XCTAssertEqual(jobs.count, 1)
+      XCTAssertEqual(jobs[0].kind, .interpret)
+      let interpretJob = jobs[0]
       let resolver = try ArgsResolver(fileSystem: localFileSystem)
-      let resolvedArgs: [String] = try resolver.resolveArgumentList(for: testJob)
-      XCTAssertEqual(resolvedArgs.count, 3)
-      XCTAssertEqual(resolvedArgs[2].first, "@")
-      let responseFilePath = try AbsolutePath(validating: String(resolvedArgs[2].dropFirst()))
-      XCTAssertEqual(responseFilePath.basename, "arguments-847d15e70d97df7c18033735497ca8dcc4441f461d5a9c2b764b127004524e81.resp")
+      let resolvedArgs: [String] = try resolver.resolveArgumentList(for: interpretJob)
+      XCTAssertFalse(resolvedArgs.contains { $0.hasPrefix("@") })
     }
   }