Always apply working-directory in the swift-driver

Sources/SwiftDriver/Driver/Driver.swift

@@ -325,8 +325,7 @@ public struct Driver {
     case .absolute(let path):
       return path
     case .relative(let path):
-      let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory
-      return cwd.map { AbsolutePath($0, path) }
+      return workingDirectory.map { AbsolutePath($0, path) }
     case .standardInput, .standardOutput, .temporary, .temporaryWithKnownContents, .fileList:
       fatalError("Frontend target information will never include a path of this type.")
     }
@@ -643,10 +642,10 @@ public struct Driver {
                                                                                         compilerMode: compilerMode)
 
     // Compute the working directory.
+    let cwd = fileSystem.currentWorkingDirectory
     workingDirectory = try parsedOptions.getLastArgument(.workingDirectory).map { workingDirectoryArg in
-      let cwd = fileSystem.currentWorkingDirectory
       return try cwd.map{ try AbsolutePath(validating: workingDirectoryArg.asSingle, relativeTo: $0) } ?? AbsolutePath(validating: workingDirectoryArg.asSingle)
-    }
+    } ?? cwd
 
     // Apply the working directory to the parsed options.
     if let workingDirectory = self.workingDirectory {
@@ -791,7 +790,7 @@ public struct Driver {
     self.buildRecordInfo = BuildRecordInfo(
       actualSwiftVersion: self.frontendTargetInfo.compilerVersion,
       compilerOutputType: compilerOutputType,
-      workingDirectory: self.workingDirectory ?? fileSystem.currentWorkingDirectory,
+      workingDirectory: self.workingDirectory,
       diagnosticEngine: diagnosticEngine,
       fileSystem: fileSystem,
       moduleOutputInfo: moduleOutputInfo,
@@ -3001,7 +3000,7 @@ extension Driver {
     }
 
     if let profileArgs = parsedOptions.getLastArgument(.profileUse)?.asMultiple,
-       let workingDirectory = workingDirectory ?? fileSystem.currentWorkingDirectory {
+       let workingDirectory = workingDirectory {
       for profilingData in profileArgs {
         if let path = try? AbsolutePath(validating: profilingData,
                                           relativeTo: workingDirectory) {

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -202,7 +202,9 @@ public extension Driver {
     let isSwiftScanLibAvailable = !(try initSwiftScanLib())
     if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
-      let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory!
+      guard let cwd = workingDirectory else {
+        throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
+      }
       var command = try Self.itemizedJobCommand(of: preScanJob,
                                                 useResponseFiles: .disabled,
                                                 using: executor.resolver)
@@ -272,7 +274,9 @@ public extension Driver {
     let isSwiftScanLibAvailable = !(try initSwiftScanLib())
     if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
-      let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory!
+      guard let cwd = workingDirectory else {
+        throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
+      }
       var command = try Self.itemizedJobCommand(of: scannerJob,
                                                 useResponseFiles: .disabled,
                                                 using: executor.resolver)
@@ -309,7 +313,9 @@ public extension Driver {
     let isSwiftScanLibAvailable = !(try initSwiftScanLib())
     if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
-      let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory!
+      guard let cwd = workingDirectory else {
+        throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
+      }
       var command = try Self.itemizedJobCommand(of: batchScanningJob,
                                                 useResponseFiles: .disabled,
                                                 using: executor.resolver)

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -374,7 +374,7 @@ extension Driver {
       if let compilationDir = parsedOptions.getLastArgument(.fileCompilationDir)?.asSingle {
         let compDirPath = try VirtualPath.intern(path: compilationDir)
         try addPathArgument(VirtualPath.lookup(compDirPath), to:&commandLine, remap: jobNeedPathRemap)
-      } else if let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory {
+      } else if let cwd = workingDirectory {
         let compDirPath = VirtualPath.absolute(cwd)
         try addPathArgument(compDirPath, to:&commandLine, remap: jobNeedPathRemap)
       }
@@ -774,7 +774,7 @@ extension Driver {
 
 extension Driver {
   private func getAbsolutePathFromVirtualPath(_ path: VirtualPath) -> AbsolutePath? {
-    guard let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory else {
+    guard let cwd = workingDirectory else {
       return nil
     }
     return path.resolvedRelativePath(base: cwd).absolutePath

Sources/SwiftDriver/Jobs/PrintTargetInfoJob.swift

@@ -190,7 +190,7 @@ extension Driver {
        fileSystem.exists(swiftScanLibPath) {
       let libSwiftScanInstance = try SwiftScan(dylib: swiftScanLibPath)
       if libSwiftScanInstance.canQueryTargetInfo() {
-        let cwd = try workingDirectory ?? fileSystem.currentWorkingDirectory ?? fileSystem.tempDirectory
+        let cwd = try workingDirectory ?? fileSystem.tempDirectory
         let compilerExecutablePath = try toolchain.resolvedTool(.swiftCompiler).path
         let targetInfoData =
           try libSwiftScanInstance.queryTargetInfoJSON(workingDirectory: cwd,

Sources/SwiftOptions/Options.swift

@@ -814,7 +814,7 @@ extension Option {
   public static let vfsoverlayEQ: Option = Option("-vfsoverlay=", .joined, alias: Option.vfsoverlay)
   public static let vfsoverlay: Option = Option("-vfsoverlay", .joinedOrSeparate, attributes: [.frontend, .argumentIsPath], helpText: "Add directory to VFS overlay file")
   public static let visualcToolsRoot: Option = Option("-visualc-tools-root", .separate, attributes: [.frontend, .argumentIsPath], metaVar: "<root>", helpText: "VisualC++ Tools Root")
-  public static let visualcToolsVersion: Option = Option("-visualc-tools-version", .separate, attributes: [.frontend, .argumentIsPath], metaVar: "<version>", helpText: "VisualC++ ToolSet Version")
+  public static let visualcToolsVersion: Option = Option("-visualc-tools-version", .separate, attributes: [.frontend,], metaVar: "<version>", helpText: "VisualC++ ToolSet Version")
   public static let v: Option = Option("-v", .flag, attributes: [.doesNotAffectIncrementalBuild], helpText: "Show commands to run and use verbose output")
   public static let warnConcurrency: Option = Option("-warn-concurrency", .flag, attributes: [.frontend, .doesNotAffectIncrementalBuild], helpText: "Warn about code that is unsafe according to the Swift Concurrency model and will become ill-formed in a future language version")
   public static let warnImplicitOverrides: Option = Option("-warn-implicit-overrides", .flag, attributes: [.frontend, .doesNotAffectIncrementalBuild], helpText: "Warn about implicit overrides of protocol members")
@@ -832,7 +832,7 @@ extension Option {
   public static let weakLinkAtTarget: Option = Option("-weak-link-at-target", .flag, attributes: [.helpHidden, .frontend, .noDriver], helpText: "Weakly link symbols for declarations that were introduced at the deployment target. Symbols introduced before the deployment target are still strongly linked.")
   public static let wholeModuleOptimization: Option = Option("-whole-module-optimization", .flag, attributes: [.frontend, .noInteractive], helpText: "Optimize input files together instead of individually")
   public static let windowsSdkRoot: Option = Option("-windows-sdk-root", .separate, attributes: [.frontend, .argumentIsPath], metaVar: "<root>", helpText: "Windows SDK Root")
-  public static let windowsSdkVersion: Option = Option("-windows-sdk-version", .separate, attributes: [.frontend, .argumentIsPath], metaVar: "<version>", helpText: "Windows SDK Version")
+  public static let windowsSdkVersion: Option = Option("-windows-sdk-version", .separate, attributes: [.frontend], metaVar: "<version>", helpText: "Windows SDK Version")
   public static let wmo: Option = Option("-wmo", .flag, alias: Option.wholeModuleOptimization, attributes: [.helpHidden, .frontend, .noInteractive])
   public static let workingDirectoryEQ: Option = Option("-working-directory=", .joined, alias: Option.workingDirectory)
   public static let workingDirectory: Option = Option("-working-directory", .separate, metaVar: "<path>", helpText: "Resolve file paths relative to the specified directory")

Tests/SwiftDriverTests/APIDigesterTests.swift

@@ -48,22 +48,22 @@ class APIDigesterTests: XCTestCase {
     do {
       var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module", "-emit-digester-baseline"])
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateAPIBaseline })
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "foo.api.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("foo.api.json")]))
     }
     do {
       var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module","-emit-module-interface", "-enable-library-evolution", "-emit-digester-baseline", "-digester-mode", "abi"])
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateABIBaseline })
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "foo.abi.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("foo.abi.json")]))
     }
     do {
       var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module", "-emit-digester-baseline-path", "bar.api.json"])
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateAPIBaseline })
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "bar.api.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("bar.api.json")]))
     }
     do {
       var driver = try Driver(args: ["swiftc", "foo.swift", "-emit-module","-emit-module-interface", "-enable-library-evolution", "-digester-mode", "abi", "-emit-digester-baseline-path", "bar.abi.json"])
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateABIBaseline })
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "bar.abi.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("bar.abi.json")]))
     }
     do {
       try withTemporaryDirectory { path in
@@ -148,11 +148,11 @@ class APIDigesterTests: XCTestCase {
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateAPIBaseline })
       XCTAssertTrue(digesterJob.commandLine.contains("-dump-sdk"))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-module", "foo"]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.relative(try .init(validating: ".")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", try toPathOption(".")]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-sdk", .path(.absolute(try .init(validating: "/path/to/sdk")))]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.absolute(try .init(validating: "/some/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", .path(.relative(try .init(validating: "framework/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "foo.api.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", try toPathOption("framework/path")]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("foo.api.json")]))
 
       XCTAssertFalse(digesterJob.commandLine.contains("-abi"))
     }
@@ -164,11 +164,11 @@ class APIDigesterTests: XCTestCase {
       let digesterJob = try XCTUnwrap(driver.planBuild().first { $0.kind == .generateABIBaseline })
       XCTAssertTrue(digesterJob.commandLine.contains("-dump-sdk"))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-module", "foo"]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.relative(try .init(validating: ".")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", try toPathOption(".")]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-sdk", .path(.absolute(try .init(validating: "/path/to/sdk")))]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.absolute(try .init(validating: "/some/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", .path(.relative(try .init(validating: "framework/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", .path(.relative(try .init(validating: "foo.abi.json")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", try toPathOption("framework/path")]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-o", try toPathOption("foo.abi.json")]))
 
       XCTAssertTrue(digesterJob.commandLine.contains("-abi"))
     }
@@ -239,12 +239,12 @@ class APIDigesterTests: XCTestCase {
       XCTAssertTrue(digesterJob.commandLine.contains("-diagnose-sdk"))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-module", "foo"]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-baseline-path", .path(.absolute(try .init(validating: "/baseline/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.relative(try .init(validating: ".")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", try toPathOption(".")]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-sdk", .path(.absolute(try .init(validating: "/path/to/sdk")))]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-I", .path(.absolute(try .init(validating: "/some/path")))]))
-      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", .path(.relative(try .init(validating: "framework/path")))]))
+      XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-F", try toPathOption("framework/path")]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-breakage-allowlist-path",
-                                                                   .path(.relative(try .init(validating: "allowlist/path")))]))
+                                                                   try toPathOption("allowlist/path")]))
 
       XCTAssertFalse(digesterJob.commandLine.contains("-abi"))
     }
@@ -259,7 +259,7 @@ class APIDigesterTests: XCTestCase {
       XCTAssertTrue(digesterJob.commandLine.contains("-diagnose-sdk"))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-input-paths", .path(.absolute(try .init(validating: "/baseline/path")))]))
       XCTAssertTrue(digesterJob.commandLine.contains(subsequence: ["-breakage-allowlist-path",
-                                                                   .path(.relative(try .init(validating: "allowlist/path")))]))
+                                                                   try toPathOption("allowlist/path")]))
       XCTAssertTrue(digesterJob.commandLine.contains("-abi"))
       XCTAssertTrue(digesterJob.commandLine.contains("-serialize-diagnostics-path"))
     }

Tests/SwiftDriverTests/CachingBuildTests.swift

@@ -320,6 +320,9 @@ final class CachingBuildTests: XCTestCase {
             case .relative(try RelativePath(validating: "testCachingBuildJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testCachingBuildJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testCachingBuildJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||
@@ -454,6 +457,9 @@ final class CachingBuildTests: XCTestCase {
             case .relative(try RelativePath(validating: "testExplicitModuleVerifyInterfaceJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testExplicitModuleVerifyInterfaceJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testExplicitModuleVerifyInterfaceJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||

Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift

@@ -384,6 +384,9 @@ final class ExplicitModuleBuildTests: XCTestCase {
             case .relative(try .init(validating: "testExplicitModuleBuildJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testExplicitModuleBuildJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testExplicitModuleBuildJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||
@@ -514,6 +517,9 @@ final class ExplicitModuleBuildTests: XCTestCase {
             case .relative(try .init(validating: "testExplicitModuleVerifyInterfaceJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testExplicitModuleVerifyInterfaceJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testExplicitModuleVerifyInterfaceJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||
@@ -648,6 +654,9 @@ final class ExplicitModuleBuildTests: XCTestCase {
             case .relative(try .init(validating: "testExplicitModuleBuildPCHOutputJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testExplicitModuleBuildPCHOutputJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testExplicitModuleBuildPCHOutputJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||
@@ -752,6 +761,9 @@ final class ExplicitModuleBuildTests: XCTestCase {
             case .relative(try .init(validating: "testExplicitModuleBuildJobs")):
               XCTAssertTrue(driver.isExplicitMainModuleJob(job: job))
               XCTAssertEqual(job.kind, .link)
+            case .absolute(let path):
+              XCTAssertEqual(path.basename, "testExplicitModuleBuildJobs")
+              XCTAssertEqual(job.kind, .link)
             case .temporary(_):
               let baseName = "testExplicitModuleBuildJobs"
               XCTAssertTrue(matchTemporary(outputFilePath, basename: baseName, fileExtension: "o") ||