Make swift driver friendlier to relative paths

Add handling for relative paths in output file map path,
resonse file paths, recorded input modification dates.

Author: zienag

Sources/SwiftDriver/Driver/Driver.swift

@@ -252,17 +252,15 @@ public struct Driver {
     self.inputFiles = inputFiles
     self.recordedInputModificationDates = .init(uniqueKeysWithValues:
       Set(inputFiles).compactMap {
-        if case .absolute(let absolutePath) = $0.file,
-          let modTime = try? localFileSystem.getFileInfo(absolutePath).modTime {
-          return ($0, modTime)
-        }
-        return nil
+        guard let modTime = try? localFileSystem
+          .getFileInfo($0.file).modTime else { return nil }
+        return ($0, modTime)
     })
 
     let outputFileMap: OutputFileMap?
     // Initialize an empty output file map, which will be populated when we start creating jobs.
     if let outputFileMapArg = parsedOptions.getLastArgument(.outputFileMap)?.asSingle {
-      let path = try AbsolutePath(validating: outputFileMapArg)
+      let path = try VirtualPath(path: outputFileMapArg)
       outputFileMap = try .load(file: path, diagnosticEngine: diagnosticEngine)
     } else {
       outputFileMap = nil
@@ -504,13 +502,13 @@ extension Driver {
   private static func expandResponseFiles(
     _ args: [String],
     diagnosticsEngine: DiagnosticsEngine,
-    visitedResponseFiles: inout Set<AbsolutePath>
+    visitedResponseFiles: inout Set<VirtualPath>
   ) throws -> [String] {
     var result: [String] = []
 
     // Go through each arg and add arguments from response files.
     for arg in args {
-      if arg.first == "@", let responseFile = try? AbsolutePath(validating: String(arg.dropFirst())) {
+      if arg.first == "@", let responseFile = try? VirtualPath(path: String(arg.dropFirst())) {
         // Guard against infinite parsing loop.
         guard visitedResponseFiles.insert(responseFile).inserted else {
           diagnosticsEngine.emit(.warn_recursive_response_file(responseFile))
@@ -536,7 +534,7 @@ extension Driver {
     _ args: [String],
     diagnosticsEngine: DiagnosticsEngine
   ) throws -> [String] {
-    var visitedResponseFiles = Set<AbsolutePath>()
+    var visitedResponseFiles = Set<VirtualPath>()
     return try expandResponseFiles(args, diagnosticsEngine: diagnosticsEngine, visitedResponseFiles: &visitedResponseFiles)
   }
 }
@@ -694,7 +692,7 @@ extension Driver {
 }
 
 extension Diagnostic.Message {
-  static func warn_recursive_response_file(_ path: AbsolutePath) -> Diagnostic.Message {
+  static func warn_recursive_response_file(_ path: VirtualPath) -> Diagnostic.Message {
     .warning("response file '\(path)' is recursively expanded")
   }
 
@@ -837,16 +835,8 @@ extension Driver {
       }
 
       // Resolve the input file.
-      let file: VirtualPath
-      let fileExtension: String
-      if let absolute = try? AbsolutePath(validating: input) {
-        file = .absolute(absolute)
-        fileExtension = absolute.extension ?? ""
-      } else {
-        let relative = try RelativePath(validating: input)
-        fileExtension = relative.extension ?? ""
-        file = .relative(relative)
-      }
+      let file = try VirtualPath(path: input)
+      let fileExtension = file.extension ?? ""
 
       // Determine the type of the input file based on its extension.
       // If we don't recognize the extension, treat it as an object file.

Sources/SwiftDriver/Driver/OutputFileMap.swift

@@ -68,7 +68,7 @@ public struct OutputFileMap: Equatable {
 
   /// Load the output file map at the given path.
   public static func load(
-    file: AbsolutePath,
+    file: VirtualPath,
     diagnosticEngine: DiagnosticsEngine
   ) throws -> OutputFileMap {
     // Load and decode the file.

Sources/SwiftDriver/Incremental Compilation/IncrementalCompilation.swift

@@ -16,7 +16,7 @@ import Foundation
 public struct IncrementalCompilation {
   public let showIncrementalBuildDecisions: Bool
   public let enableIncrementalBuild: Bool
-  public let buildRecordPath: AbsolutePath?
+  public let buildRecordPath: VirtualPath?
   public let outputBuildRecordForModuleOnlyBuild: Bool
   public let argsHash: String
   public let lastBuildTime: Date
@@ -118,14 +118,14 @@ public struct IncrementalCompilation {
     outputFileMap: OutputFileMap?,
     compilerOutputType: FileType?,
     diagnosticEngine: DiagnosticsEngine?
-  ) -> AbsolutePath? {
+  ) -> VirtualPath? {
     // FIXME: This should work without an output file map. We should have
     // another way to specify a build record and where to put intermediates.
     guard let ofm = outputFileMap else {
       diagnosticEngine.map { $0.emit(.warning_incremental_requires_output_file_map) }
       return nil
     }
-    guard let partialBuildRecordPath = ofm.existingOutputForSingleInput(outputType: .swiftDeps)?.absolutePath
+    guard let partialBuildRecordPath = ofm.existingOutputForSingleInput(outputType: .swiftDeps)
       else {
         diagnosticEngine.map { $0.emit(.warning_incremental_requires_build_record_entry) }
         return nil
@@ -134,7 +134,7 @@ public struct IncrementalCompilation {
     // '~moduleonly'. So that module-only mode doesn't mess up build-record
     // file for full compilation.
     return compilerOutputType == .swiftModule
-      ? AbsolutePath(partialBuildRecordPath.pathString + "~moduleonly")
+      ? partialBuildRecordPath.appendingToBaseName("~moduleonly")
       : partialBuildRecordPath
   }
 

Sources/SwiftDriver/Incremental Compilation/InputIInfoMap.swift

@@ -130,7 +130,7 @@ public extension InputInfoMap {
     argsHash: String,
     lastBuildTime: Date,
     inputFiles: [TypedVirtualPath],
-    buildRecordPath: AbsolutePath,
+    buildRecordPath: VirtualPath,
     showIncrementalBuildDecisions: Bool,
     diagnosticEngine: DiagnosticsEngine
   ) -> Self? {

Sources/SwiftDriver/Utilities/VirtualPath.swift

@@ -109,6 +109,23 @@ public enum VirtualPath: Hashable {
       return self
     }
   }
+
+  /// Returns the virtual path with an additional suffix appended to base name.
+  ///
+  /// This should not be used with `.standardInput` or `.standardOutput`.
+  public func appendingToBaseName(_ suffix: String) -> VirtualPath {
+    switch self {
+    case let .absolute(path):
+      return .absolute(AbsolutePath(path.pathString + suffix))
+    case let .relative(path):
+      return .relative(RelativePath(path.pathString + suffix))
+    case let .temporary(path):
+      return .temporary(RelativePath(path.pathString + suffix))
+    case .standardInput, .standardOutput:
+      assertionFailure("Can't append path component to standard in/out")
+      return self
+    }
+  }
 }
 
 extension VirtualPath: Codable {
@@ -193,3 +210,41 @@ extension VirtualPath {
     return try VirtualPath(path: pathString.appendingFileTypeExtension(fileType))
   }
 }
+
+enum FileSystemError: Swift.Error {
+  case noCurrentWorkingDirectory
+  case cannotResolveTempPath(RelativePath)
+  case cannotResolveStandardInput
+  case cannotResolveStandardOutput
+}
+
+extension TSCBasic.FileSystem {
+  private func resolvingVirtualPath<T>(
+    _ path: VirtualPath,
+    apply f: (AbsolutePath) throws -> T
+  ) throws -> T {
+    switch path {
+    case let .absolute(absPath):
+      return try f(absPath)
+    case let .relative(relPath):
+      guard let cwd = currentWorkingDirectory else {
+        throw FileSystemError.noCurrentWorkingDirectory
+      }
+      return try f(.init(cwd, relPath))
+    case let .temporary(relPath):
+      throw FileSystemError.cannotResolveTempPath(relPath)
+    case .standardInput:
+      throw FileSystemError.cannotResolveStandardInput
+    case .standardOutput:
+      throw FileSystemError.cannotResolveStandardOutput
+    }
+  }
+
+  func readFileContents(_ path: VirtualPath) throws -> ByteString {
+    try resolvingVirtualPath(path, apply: readFileContents)
+  }
+
+  func getFileInfo(_ path: VirtualPath) throws -> TSCBasic.FileInfo {
+    try resolvingVirtualPath(path, apply: getFileInfo)
+  }
+}

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -207,6 +207,28 @@ final class SwiftDriverTests: XCTestCase {
     XCTAssertEqual(driver4.inputFiles, [ TypedVirtualPath(file: .standardInput, type: .swift )])
   }
 
+  func testRecordedInputModificationDates() throws {
+    try withTemporaryDirectory { path in
+      guard let cwd = localFileSystem
+        .currentWorkingDirectory else { fatalError() }
+      let main = path.appending(component: "main.swift")
+      let util = path.appending(component: "util.swift")
+      let utilRelative = util.relative(to: cwd)
+      try localFileSystem.writeFileContents(main) { $0 <<< "print(hi)" }
+      try localFileSystem.writeFileContents(util) { $0 <<< "let hi = \"hi\"" }
+
+      let mainMDate = try localFileSystem.getFileInfo(main).modTime
+      let utilMDate = try localFileSystem.getFileInfo(util).modTime
+      let driver = try Driver(args: [
+        "swiftc", main.pathString, utilRelative.pathString,
+      ])
+      XCTAssertEqual(driver.recordedInputModificationDates, [
+        .init(file: .absolute(main), type: .swift) : mainMDate,
+        .init(file: .relative(utilRelative), type: .swift) : utilMDate,
+      ])
+    }
+  }
+
   func testPrimaryOutputKinds() throws {
     let driver1 = try Driver(args: ["swiftc", "foo.swift", "-emit-module"])
     XCTAssertEqual(driver1.compilerOutputType, .swiftModule)
@@ -453,7 +475,7 @@ final class SwiftDriverTests: XCTestCase {
     try withTemporaryFile { file in
       try assertNoDiagnostics { diags in
         try localFileSystem.writeFileContents(file.path) { $0 <<< contents }
-        let outputFileMap = try OutputFileMap.load(file: file.path, diagnosticEngine: diags)
+        let outputFileMap = try OutputFileMap.load(file: .absolute(file.path), diagnosticEngine: diags)
 
         let object = try outputFileMap.getOutput(inputFile: .init(path: "/tmp/foo/Sources/foo/foo.swift"), outputType: .object)
         XCTAssertEqual(object.name, "/tmp/foo/.build/x86_64-apple-macosx/debug/foo.build/foo.swift.o")
@@ -489,7 +511,7 @@ final class SwiftDriverTests: XCTestCase {
       try sampleOutputFileMap.store(file: file.path, diagnosticEngine: DiagnosticsEngine())
       let contentsForDebugging = try localFileSystem.readFileContents(file.path).cString
       _ = contentsForDebugging
-      let recoveredOutputFileMap = try OutputFileMap.load(file: file.path, diagnosticEngine: DiagnosticsEngine())
+      let recoveredOutputFileMap = try OutputFileMap.load(file: .absolute(file.path), diagnosticEngine: DiagnosticsEngine())
       XCTAssertEqual(sampleOutputFileMap, recoveredOutputFileMap)
     }
   }
@@ -532,6 +554,38 @@ final class SwiftDriverTests: XCTestCase {
     XCTAssertEqual(expectedOutputFileMap, resolvedOutputFileMap)
   }
 
+  func testOutputFileMapRelativePathArg() throws {
+    try withTemporaryDirectory { path in
+      guard let cwd = localFileSystem
+        .currentWorkingDirectory else { fatalError() }
+      let outputFileMap = path.appending(component: "outputFileMap.json")
+      try localFileSystem.writeFileContents(outputFileMap) {
+        $0 <<< """
+        {
+          "": {
+            "swift-dependencies": "build/master.swiftdeps"
+          },
+          "main.swift": {
+            "object": "build/main.o",
+            "dependencies": "build/main.o.d"
+          },
+          "util.swift": {
+            "object": "build/util.o",
+            "dependencies": "build/util.o.d"
+          }
+        }
+        """
+      }
+      let outputFileMapRelative = outputFileMap.relative(to: cwd).pathString
+      // FIXME: Needs a better way to check that outputFileMap correctly loaded
+      XCTAssertNoThrow(try Driver(args: [
+        "swiftc",
+        "--output-file-map", outputFileMapRelative,
+        "main.swift", "util.swift",
+      ]))
+    }
+  }
+
   func testResponseFileExpansion() throws {
     try withTemporaryDirectory { path in
       let diags = DiagnosticsEngine()
@@ -640,6 +694,31 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testResponseFile() throws {
+    try withTemporaryDirectory { path in
+      guard let cwd = localFileSystem
+        .currentWorkingDirectory else { fatalError() }
+      let responseFile1 = path.appending(component: "fileList1.rsp")
+      let responseFile2 = path.appending(component: "fileList2.rsp")
+      try localFileSystem.writeFileContents(responseFile1) {
+        $0 <<< "from1stList.swift"
+      }
+      try localFileSystem.writeFileContents(responseFile2) {
+        $0 <<< "from2ndList.swift"
+      }
+      let responseFile2Relative = responseFile2.relative(to: cwd)
+      let driver = try Driver(args: [
+        "swiftc",
+        "@\(responseFile1.pathString)",
+        "@\(responseFile2Relative)",
+      ])
+      XCTAssertEqual(driver.inputFiles, [
+        .init(file: .relative(.init("from1stList.swift")), type: .swift),
+        .init(file: .relative(.init("from2ndList.swift")), type: .swift),
+      ])
+    }
+  }
+
   func testLinking() throws {
     var env = ProcessEnv.vars
     env["SWIFT_DRIVER_TESTS_ENABLE_EXEC_PATH_FALLBACK"] = "1"