Compute cache key when needed

Author: cachemeifyoucan

Sources/SwiftDriver/Driver/Driver.swift

@@ -207,11 +207,6 @@ public struct Driver {
   /// CacheKey for bridging header
   var bridgingHeaderCacheKey: String? = nil
 
-  /// CacheKey for swift interface
-  var swiftInterfaceCacheKey: String? = nil
-  /// CacheKey for private swift interface
-  var privateSwiftInterfaceCacheKey: String? = nil
-
   /// The set of input files
   @_spi(Testing) public let inputFiles: [TypedVirtualPath]
 

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -394,9 +394,6 @@ extension Driver {
       displayInputs = primaryInputs
     }
 
-    // Assume swiftinterface file is always the supplementary output for first input file.
-    try computeCacheKeyForInterface(mainInput: displayInputs[0], outputs: outputs, commandLine: commandLine)
-
     return Job(
       moduleName: moduleOutputInfo.name,
       kind: .compile,

Sources/SwiftDriver/Jobs/EmitModuleJob.swift

@@ -118,8 +118,6 @@ extension Driver {
       commandLine.appendPath(abiPath.file)
       outputs.append(abiPath)
     }
-    // Assume swiftinterface file is always the supplementary output for first input file.
-    try computeCacheKeyForInterface(mainInput: inputs[0], outputs: outputs, commandLine: commandLine)
     return Job(
       moduleName: moduleOutputInfo.name,
       kind: .emitModule,

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -671,23 +671,6 @@ extension Driver {
     try dependencyPlanner.resolveBridgingHeaderDependencies(inputs: &inputs, commandLine: &commandLine)
   }
 
-  /// Compute the cache key for swift interface outputs.
-  mutating func computeCacheKeyForInterface(mainInput: TypedVirtualPath,
-                                            outputs: [TypedVirtualPath],
-                                            commandLine: [Job.ArgTemplate]) throws {
-    if enableCaching {
-      func computeKeyForInterface(forPrivate: Bool) throws -> String? {
-        let outputType: FileType =
-          forPrivate ? .privateSwiftInterface : .swiftInterface
-        let isNeeded = outputs.contains { $0.type == outputType  }
-        guard isNeeded else { return nil }
-        return try interModuleDependencyOracle.computeCacheKeyForOutput(kind: outputType, commandLine: commandLine, input: mainInput.fileHandle)
-      }
-      swiftInterfaceCacheKey = try computeKeyForInterface(forPrivate: false)
-      privateSwiftInterfaceCacheKey = try computeKeyForInterface(forPrivate: true)
-    }
-  }
-
   /// In Explicit Module Build mode, distinguish between main module jobs and intermediate dependency build jobs,
   /// such as Swift modules built from .swiftmodule files and Clang PCMs.
   public func isExplicitMainModuleJob(job: Job) -> Bool {

Sources/SwiftDriver/Jobs/Planning.swift

@@ -564,7 +564,9 @@ extension Driver {
       let mergeInterfaceOutputs = emitModuleJob.outputs.filter { $0.type == outputType }
       assert(mergeInterfaceOutputs.count == 1,
              "Merge module job should only have one swiftinterface output")
-      let job = try verifyModuleInterfaceJob(interfaceInput: mergeInterfaceOutputs[0], optIn: optIn)
+      let job = try verifyModuleInterfaceJob(interfaceInput: mergeInterfaceOutputs[0],
+                                             emitModuleJob: emitModuleJob,
+                                             optIn: optIn)
       addJob(job)
     }
     try addVerifyJob(forPrivate: false)

Sources/SwiftDriver/Jobs/VerifyModuleInterfaceJob.swift

@@ -11,7 +11,21 @@
 //===----------------------------------------------------------------------===//
 
 extension Driver {
-  mutating func verifyModuleInterfaceJob(interfaceInput: TypedVirtualPath, optIn: Bool) throws -> Job {
+  func computeCacheKeyForInterface(emitModuleJob: Job,
+                                   interfaceKind: FileType) throws -> String? {
+    assert(interfaceKind == .swiftInterface || interfaceKind == .privateSwiftInterface,
+           "only expect interface output kind")
+    let isNeeded = emitModuleJob.outputs.contains { $0.type == interfaceKind }
+    guard enableCaching && isNeeded else { return nil }
+
+    // Assume swiftinterface file is always the supplementary output for first input file.
+    let mainInput = emitModuleJob.inputs[0]
+    return try interModuleDependencyOracle.computeCacheKeyForOutput(kind: interfaceKind,
+                                                                    commandLine: emitModuleJob.commandLine,
+                                                                    input: mainInput.fileHandle)
+  }
+
+  mutating func verifyModuleInterfaceJob(interfaceInput: TypedVirtualPath, emitModuleJob: Job, optIn: Bool) throws -> Job {
     var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
     var inputs: [TypedVirtualPath] = [interfaceInput]
     commandLine.appendFlags("-frontend", "-typecheck-module-from-interface")
@@ -28,11 +42,7 @@ extension Driver {
 
     if parsedOptions.contains(.driverExplicitModuleBuild) {
       commandLine.appendFlag("-explicit-interface-module-build")
-      if let key = swiftInterfaceCacheKey, interfaceInput.type == .swiftInterface {
-        commandLine.appendFlag("-input-file-key")
-        commandLine.appendFlag(key)
-      }
-      if let key = privateSwiftInterfaceCacheKey, interfaceInput.type == .privateSwiftInterface {
+      if let key = try computeCacheKeyForInterface(emitModuleJob: emitModuleJob, interfaceKind: interfaceInput.type) {
         commandLine.appendFlag("-input-file-key")
         commandLine.appendFlag(key)
       }