[Caching] Path remapping support

Teach swift-driver to remap path when needed. This involves:
* Infer SDK/toolchain related path that needs to remapped
* Send path remap related arguments to swift-frontend for depscanning
* Send reverse map to swift-frontend for diagnostics replay
* Constructing the compilation command for main module using remapped
  path

Author: cachemeifyoucan

Sources/SwiftDriver/Driver/Driver.swift

@@ -272,6 +272,35 @@ public struct Driver {
   let enableCaching: Bool
   let useClangIncludeTree: Bool
 
+  /// Scanner prefix mapping.
+  let scannerPrefixMap: [AbsolutePath: AbsolutePath]
+  let scannerPrefixMapSDK: AbsolutePath?
+  let scannerPrefixMapToolchain: AbsolutePath?
+  lazy var prefixMapping: [(AbsolutePath, AbsolutePath)] = {
+    var mapping: [(AbsolutePath, AbsolutePath)] = scannerPrefixMap.map {
+      return ($0.key, $0.value)
+    }
+    do {
+      guard isFrontendArgSupported(.scannerPrefixMap) else {
+        return []
+      }
+      if let sdkMapping = scannerPrefixMapSDK,
+         let sdkPath = absoluteSDKPath {
+        mapping.append((sdkPath, sdkMapping))
+      }
+      if let toolchainMapping = scannerPrefixMapToolchain {
+        let toolchainPath = try toolchain.executableDir.parentDirectory // usr
+                                                       .parentDirectory // toolchain
+        mapping.append((toolchainPath, toolchainMapping))
+      }
+      // The mapping needs to be sorted so the mapping is determinisitic.
+      // The sorting order is reversed so /tmp/tmp is preferred over /tmp in remapping.
+      return mapping.sorted { $0.0 > $1.0 }
+    } catch {
+      return mapping.sorted { $0.0 > $1.0 }
+    }
+  }()
+
   /// Code & data for incremental compilation. Nil if not running in incremental mode.
   /// Set during planning because needs the jobs to look at outputs.
   @_spi(Testing) public private(set) var incrementalCompilationState: IncrementalCompilationState? = nil
@@ -595,6 +624,17 @@ public struct Driver {
     let cachingEnableOverride = parsedOptions.hasArgument(.driverExplicitModuleBuild) && env.keys.contains("SWIFT_ENABLE_CACHING")
     self.enableCaching = parsedOptions.hasArgument(.cacheCompileJob) || cachingEnableOverride
     self.useClangIncludeTree = enableCaching && env.keys.contains("SWIFT_CACHING_USE_INCLUDE_TREE")
+    self.scannerPrefixMap = try Self.computeScanningPrefixMapper(&parsedOptions)
+    if let sdkMapping =  parsedOptions.getLastArgument(.scannerPrefixMapSdk)?.asSingle {
+      self.scannerPrefixMapSDK = try AbsolutePath(validating: sdkMapping)
+    } else {
+      self.scannerPrefixMapSDK = nil
+    }
+    if let toolchainMapping = parsedOptions.getLastArgument(.scannerPrefixMapToolchain)?.asSingle {
+      self.scannerPrefixMapToolchain = try AbsolutePath(validating: toolchainMapping)
+    } else {
+      self.scannerPrefixMapToolchain = nil
+    }
 
     // Compute the working directory.
     workingDirectory = try parsedOptions.getLastArgument(.workingDirectory).map { workingDirectoryArg in
@@ -3490,4 +3530,18 @@ extension Driver {
     }
     return options
   }
+
+  static func computeScanningPrefixMapper(_ parsedOptions: inout ParsedOptions) throws -> [AbsolutePath: AbsolutePath] {
+    var mapping: [AbsolutePath: AbsolutePath] = [:]
+    for opt in parsedOptions.arguments(for: .scannerPrefixMap) {
+      let pluginArg = opt.argument.asSingle.split(separator: "=", maxSplits: 1)
+      if pluginArg.count != 2 {
+        throw Error.invalidArgumentValue(Option.scannerPrefixMap.spelling, opt.argument.asSingle)
+      }
+      let key = try AbsolutePath(validating: String(pluginArg[0]))
+      let value = try AbsolutePath(validating: String(pluginArg[1]))
+      mapping[key] = value
+    }
+    return mapping
+  }
 }

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -124,6 +124,14 @@ public extension Driver {
       try commandLine.appendLast(.clangScannerModuleCachePath, from: &parsedOptions)
     }
 
+    if isFrontendArgSupported(.scannerPrefixMap) {
+      // construct `-scanner-prefix-mapper` for scanner.
+      for (key, value) in prefixMapping {
+        commandLine.appendFlag(.scannerPrefixMap)
+        commandLine.appendFlag(key.pathString + "=" + value.pathString)
+      }
+    }
+
     // Pass on the input files
     commandLine.append(contentsOf: inputFiles.filter { $0.type == .swift }.map { .path($0.file) })
     return (inputs, commandLine)

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -112,21 +112,21 @@ extension Driver {
                                  outputType: FileType?,
                                  commandLine: inout [Job.ArgTemplate])
   throws -> ([TypedVirtualPath], [TypedVirtualPath]) {
-    let useInputFileList: Bool
-    if let allSourcesFileList = allSourcesFileList {
-      useInputFileList = true
+    let useInputFileList = shouldUseInputFileList
+    if shouldUseInputFileList {
+      let swiftInputs = inputFiles.filter(\.type.isPartOfSwiftCompilation)
+      let remappedSourcesFileList = try VirtualPath.createUniqueFilelist(RelativePath("sources"),
+                                                                         .list(swiftInputs.map{ return remapPath($0.file) }))
       commandLine.appendFlag(.filelist)
-      commandLine.appendPath(allSourcesFileList)
-    } else {
-      useInputFileList = false
+      commandLine.appendPath(remappedSourcesFileList)
     }
 
     let usePrimaryInputFileList = primaryInputs.count > fileListThreshold
     if usePrimaryInputFileList {
       // primary file list
       commandLine.appendFlag(.primaryFilelist)
       let fileList = try VirtualPath.createUniqueFilelist(RelativePath(validating: "primaryInputs"),
-                                                          .list(primaryInputs.map(\.file)))
+                                                          .list(primaryInputs.map{ return remapPath($0.file) }))
       commandLine.appendPath(fileList)
     }
 
@@ -166,12 +166,11 @@ extension Driver {
       let isPrimary = usesPrimaryFileInputs && primaryInputFiles.contains(input)
       if isPrimary {
         if !usePrimaryInputFileList {
-          commandLine.appendFlag(.primaryFile)
-          commandLine.appendPath(input.file)
+          try addPathOption(option: .primaryFile, path: input.file, to:&commandLine, remap: true)
         }
       } else {
         if !useInputFileList {
-          commandLine.appendPath(input.file)
+          try addPathArgument(input.file, to: &commandLine, remap: true)
         }
       }
 

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -75,6 +75,7 @@ extension Driver {
       break
     }
 
+    let jobNeedPathRemap: Bool
     // If in ExplicitModuleBuild mode and the dependency graph has been computed, add module
     // dependencies.
     // May also be used for generation of the dependency graph itself in ExplicitModuleBuild mode.
@@ -83,17 +84,21 @@ extension Driver {
       switch kind {
       case .generatePCH:
         try addExplicitPCHBuildArguments(inputs: &inputs, commandLine: &commandLine)
+        jobNeedPathRemap = true
       case .compile, .emitModule, .interpret, .verifyModuleInterface:
         try addExplicitModuleBuildArguments(inputs: &inputs, commandLine: &commandLine)
+        jobNeedPathRemap = true
       case .backend, .mergeModule, .compileModuleFromInterface,
            .generatePCM, .dumpPCM, .repl, .printTargetInfo,
            .versionRequest, .autolinkExtract, .generateDSYM,
            .help, .link, .verifyDebugInfo, .scanDependencies,
            .emitSupportedFeatures, .moduleWrap,
            .generateAPIBaseline, .generateABIBaseline, .compareAPIBaseline,
            .compareABIBaseline:
-        break // Do not support creating from dependency scanner output.
+        jobNeedPathRemap = false
       }
+    } else {
+      jobNeedPathRemap = false
     }
 
     if let variant = parsedOptions.getLastArgument(.targetVariant)?.asSingle {
@@ -126,24 +131,22 @@ extension Driver {
     try commandLine.appendLast(.targetCpu, from: &parsedOptions)
 
     if let sdkPath = frontendTargetInfo.sdkPath?.path {
-      commandLine.appendFlag(.sdk)
-      commandLine.append(.path(VirtualPath.lookup(sdkPath)))
+      try addPathOption(option: .sdk, path: VirtualPath.lookup(sdkPath), to: &commandLine, remap: jobNeedPathRemap)
     }
 
     for args: (Option, Option) in [
           (.visualcToolsRoot, .visualcToolsVersion),
           (.windowsSdkRoot, .windowsSdkVersion)
         ] {
-      let (rootArg, versionArg) = args
-      if let value = parsedOptions.getLastArgument(rootArg)?.asSingle,
-          isFrontendArgSupported(rootArg) {
-        commandLine.appendFlag(rootArg.spelling)
-        commandLine.appendPath(try .init(validating: value))
+      let (rootOpt, versionOpt) = args
+      if let rootArg = parsedOptions.last(for: rootOpt),
+          isFrontendArgSupported(rootOpt) {
+        try addPathOption(rootArg, to: &commandLine, remap: jobNeedPathRemap)
       }
 
-      if let value = parsedOptions.getLastArgument(versionArg)?.asSingle,
-          isFrontendArgSupported(versionArg) {
-        commandLine.appendFlags(versionArg.spelling, value)
+      if let value = parsedOptions.getLastArgument(versionOpt)?.asSingle,
+          isFrontendArgSupported(versionOpt) {
+        commandLine.appendFlags(versionOpt.spelling, value)
       }
     }
 
@@ -302,12 +305,14 @@ extension Driver {
       commandLine.appendFlag(.Xcc)
       commandLine.appendFlag(.workingDirectory)
       commandLine.appendFlag(.Xcc)
-      commandLine.appendPath(.absolute(workingDirectory))
+      try addPathArgument(.absolute(workingDirectory), to: &commandLine, remap: jobNeedPathRemap)
     }
 
     // Resource directory.
-    commandLine.appendFlag(.resourceDir)
-    commandLine.appendPath(VirtualPath.lookup(frontendTargetInfo.runtimeResourcePath.path))
+    try addPathOption(option: .resourceDir,
+                      path: VirtualPath.lookup(frontendTargetInfo.runtimeResourcePath.path),
+                      to: &commandLine,
+                      remap: jobNeedPathRemap)
 
     if self.useStaticResourceDir {
       commandLine.appendFlag("-use-static-resource-dir")
@@ -347,6 +352,7 @@ extension Driver {
       try commandLine.appendAll(.casPluginOption, from: &parsedOptions)
       try commandLine.appendLast(.cacheRemarks, from: &parsedOptions)
     }
+    addCacheReplayMapping(to: &commandLine)
     if useClangIncludeTree {
       commandLine.appendFlag(.clangIncludeTree)
     }
@@ -369,16 +375,16 @@ extension Driver {
         // of a lookup failure.
         if parsedOptions.contains(.pchOutputDir) &&
            !parsedOptions.contains(.driverExplicitModuleBuild) {
-          commandLine.appendPath(VirtualPath.lookup(importedObjCHeader))
+          try addPathArgument(VirtualPath.lookup(importedObjCHeader), to:&commandLine, remap: jobNeedPathRemap)
           try commandLine.appendLast(.pchOutputDir, from: &parsedOptions)
           if !compilerMode.isSingleCompilation {
             commandLine.appendFlag(.pchDisableValidation)
           }
         } else {
-          commandLine.appendPath(VirtualPath.lookup(pch))
+          try addPathArgument(VirtualPath.lookup(pch), to:&commandLine, remap: jobNeedPathRemap)
         }
       } else {
-        commandLine.appendPath(VirtualPath.lookup(importedObjCHeader))
+        try addPathArgument(VirtualPath.lookup(importedObjCHeader), to:&commandLine, remap: jobNeedPathRemap)
       }
     }
 
@@ -418,16 +424,17 @@ extension Driver {
     }
   }
 
-  func addBridgingHeaderPCHCacheKeyArguments(commandLine: inout [Job.ArgTemplate],
-                                             pchCompileJob: Job?) throws {
+  mutating func addBridgingHeaderPCHCacheKeyArguments(commandLine: inout [Job.ArgTemplate],
+                                                      pchCompileJob: Job?) throws {
     guard let pchJob = pchCompileJob, enableCaching else { return }
 
     // The pch input file (the bridging header) is added as last inputs to the job.
     guard let inputFile = pchJob.inputs.last else { assertionFailure("no input files from pch job"); return }
     assert(inputFile.type == .objcHeader, "Expect objc header input type")
+    let mappedInput = remapPath(inputFile.file).intern()
     let bridgingHeaderCacheKey = try interModuleDependencyOracle.computeCacheKeyForOutput(kind: .pch,
                                                                                           commandLine: pchJob.commandLine,
-                                                                                          input: inputFile.fileHandle)
+                                                                                          input: mappedInput)
     commandLine.appendFlag("-bridging-header-pch-key")
     commandLine.appendFlag(bridgingHeaderCacheKey)
   }
@@ -609,7 +616,7 @@ extension Driver {
       var entries = [VirtualPath.Handle: [FileType: VirtualPath.Handle]]()
       for input in primaryInputs {
         if let output = inputOutputMap[input]?.first {
-          addEntry(&entries, input: input, output: output)
+          try addEntry(&entries, input: input, output: output)
         } else {
           // Primary inputs are expected to appear in the output file map even
           // if they have no corresponding outputs.
@@ -628,7 +635,7 @@ extension Driver {
       }
 
       for flaggedPair in flaggedInputOutputPairs {
-        addEntry(&entries, input: flaggedPair.input, output: flaggedPair.output)
+        try addEntry(&entries, input: flaggedPair.input, output: flaggedPair.output)
       }
       // To match the legacy driver behavior, make sure we add an entry for the
       // file under indexing and the primary output file path.
@@ -662,14 +669,15 @@ extension Driver {
     try commandLine.appendLast(.symbolGraphMinimumAccessLevel, from: &parsedOptions)
   }
 
-  func addEntry(_ entries: inout [VirtualPath.Handle: [FileType: VirtualPath.Handle]], input: TypedVirtualPath?, output: TypedVirtualPath) {
+  mutating func addEntry(_ entries: inout [VirtualPath.Handle: [FileType: VirtualPath.Handle]], input: TypedVirtualPath?, output: TypedVirtualPath) throws {
     let entryInput: VirtualPath.Handle
     if let input = input?.fileHandle, input != OutputFileMap.singleInputKey {
       entryInput = input
     } else {
       entryInput = inputFiles[0].fileHandle
     }
-    entries[entryInput, default: [:]][output.type] = output.fileHandle
+    let inputEntry = enableCaching ? remapPath(VirtualPath.lookup(entryInput)).intern() : entryInput
+    entries[inputEntry, default: [:]][output.type] = output.fileHandle
   }
 
   /// Adds all dependencies required for an explicit module build
@@ -706,3 +714,84 @@ extension Driver {
     return job.moduleName == moduleOutputInfo.name
   }
 }
+
+extension Driver {
+  private func getAbsolutePathFromVirtualPath(_ path: VirtualPath) -> AbsolutePath? {
+    guard let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory else {
+      return nil
+    }
+    return path.resolvedRelativePath(base: cwd).absolutePath
+  }
+
+  private mutating func remapPath(absolute path: AbsolutePath) -> AbsolutePath {
+    guard !prefixMapping.isEmpty else {
+      return path
+    }
+    for (prefix, value) in prefixMapping {
+      if path.isDescendantOfOrEqual(to: prefix) {
+        return value.appending(path.relative(to: prefix))
+      }
+    }
+    return path
+  }
+
+  public mutating func remapPath(_ path: VirtualPath) -> VirtualPath {
+    guard !prefixMapping.isEmpty,
+      let absPath = getAbsolutePathFromVirtualPath(path) else {
+      return path
+    }
+    let mappedPath = remapPath(absolute: absPath)
+    return try! VirtualPath(path: mappedPath.pathString)
+  }
+
+  /// Helper function to add path to commandLine. Function will validate the path, and remap the path if needed.
+  public mutating func addPathArgument(_ path: VirtualPath, to commandLine: inout [Job.ArgTemplate], remap: Bool = false) throws {
+    guard remap && enableCaching else {
+      commandLine.appendPath(path)
+      return
+    }
+    let mappedPath = remapPath(path)
+    commandLine.appendPath(mappedPath)
+  }
+
+  public mutating func addPathOption(_ option: ParsedOption, to commandLine: inout [Job.ArgTemplate], remap: Bool = false) throws {
+    let path = try VirtualPath(path: option.argument.asSingle)
+    try addPathOption(option: option.option, path: path, to: &commandLine, remap: remap)
+  }
+
+  public mutating func addPathOption(option: Option, path: VirtualPath, to commandLine: inout [Job.ArgTemplate], remap: Bool = false) throws {
+    commandLine.appendFlag(option)
+    let needRemap = remap && option.attributes.contains(.argumentIsPath) &&
+                    !option.attributes.contains(.cacheInvariant)
+    try addPathArgument(path, to: &commandLine, remap: needRemap)
+
+  }
+
+  /// Helper function to add last argument with path to command-line.
+  public mutating func addLastArgumentWithPath(_ options: Option...,
+                                               from parsedOptions: inout ParsedOptions,
+                                               to commandLine: inout [Job.ArgTemplate]) throws {
+    guard let parsedOption = parsedOptions.last(for: options) else {
+      return
+    }
+    try addPathOption(parsedOption, to: &commandLine)
+  }
+
+  /// Helper function to add all arguments with path to command-line.
+  public mutating func addAllArgumentsWithPath(_ options: Option...,
+                                               from parsedOptions: inout ParsedOptions,
+                                               to commandLine: inout [Job.ArgTemplate]) throws {
+    for matching in parsedOptions.arguments(for: options) {
+      try addPathOption(matching, to: &commandLine)
+    }
+  }
+
+  public mutating func addCacheReplayMapping(to commandLine: inout [Job.ArgTemplate]) {
+    if enableCaching && isFrontendArgSupported(.scannerPrefixMap) {
+      for (key, value) in prefixMapping {
+        commandLine.appendFlag("-cache-replay-prefix-map")
+        commandLine.appendFlag(value.pathString + "=" + key.pathString)
+      }
+    }
+  }
+}