[Caching] Don't produce cache key for initial compile job in batch mode

During batch mode, the initially computed compilation tasks will be
batched later. There is no need to compute cache keys for those Jobs
since they will not be executed.

Author: cachemeifyoucan

Sources/SwiftDriver/Jobs/CompileJob.swift

@@ -231,7 +231,8 @@ extension Driver {
                            outputType: FileType?,
                            addJobOutputs: ([TypedVirtualPath]) -> Void,
                            pchCompileJob: Job?,
-                           emitModuleTrace: Bool)
+                           emitModuleTrace: Bool,
+                           produceCacheKey: Bool)
   throws -> Job {
     var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
     var inputs: [TypedVirtualPath] = []

Sources/SwiftDriver/Jobs/Planning.swift

@@ -356,7 +356,8 @@ extension Driver {
                                  outputType: compilerOutputType,
                                  addJobOutputs: addJobOutputs,
                                  pchCompileJob: pchCompileJob,
-                                 emitModuleTrace: emitModuleTrace)
+                                 emitModuleTrace: emitModuleTrace,
+                                 produceCacheKey: true)
     addJob(compile)
     return compile
   }
@@ -447,11 +448,14 @@ extension Driver {
     // We can skip the compile jobs if all we want is a module when it's
     // built separately.
     if parsedOptions.hasArgument(.driverExplicitModuleBuild), canSkipIfOnlyModule { return }
+    // If we are in the batch mode, the constructed jobs here will be batched
+    // later. There is no need to produce cache key for the job.
     let compile = try compileJob(primaryInputs: [primaryInput],
                                  outputType: compilerOutputType,
                                  addJobOutputs: addJobOutputs,
                                  pchCompileJob: pchCompileJob,
-                                 emitModuleTrace: emitModuleTrace)
+                                 emitModuleTrace: emitModuleTrace,
+                                 produceCacheKey: !compilerMode.isBatchCompile)
     addCompileJob(compile)
   }
 
@@ -873,7 +877,8 @@ extension Driver {
                             outputType: compilerOutputType,
                             addJobOutputs: {_ in },
                             pchCompileJob: jobCreatingPch,
-                            emitModuleTrace: constituentsEmittedModuleTrace)
+                            emitModuleTrace: constituentsEmittedModuleTrace,
+                            produceCacheKey: true)
     }
     return batchedCompileJobs + noncompileJobs
   }

Tests/SwiftDriverTests/CachingBuildTests.swift

@@ -986,17 +986,60 @@ final class CachingBuildTests: XCTestCase {
         XCTFail("Cached compilation doesn't have a CAS")
       }
       try checkCASForResults(jobs: jobs, cas: cas, fs: driver.fileSystem)
+    }
+  }
 
-      // try replan the job and make sure some key command-line options are generated.
-      let rebuildJobs = try driver.planBuild()
-      for job in rebuildJobs {
-        if job.kind == .compile || job.kind == .emitModule {
-          XCTAssertTrue(job.commandLine.contains(.flag(String("-disable-implicit-swift-modules"))))
-          XCTAssertTrue(job.commandLine.contains(.flag(String("-cache-compile-job"))))
-          XCTAssertTrue(job.commandLine.contains(.flag(String("-cas-path"))))
-          XCTAssertTrue(job.commandLine.contains(.flag(String("-bridging-header-pch-key"))))
-        }
+  func testCacheBatchBuildPlan() throws {
+    try withTemporaryDirectory { path in
+      try localFileSystem.changeCurrentWorkingDirectory(to: path)
+      let moduleCachePath = path.appending(component: "ModuleCache")
+      let casPath = path.appending(component: "cas")
+      try localFileSystem.createDirectory(moduleCachePath)
+      let main = path.appending(component: "testCachingBuild.swift")
+      let mainFileContent = "import C;import E;import G;"
+      try localFileSystem.writeFileContents(main) {
+        $0.send(mainFileContent)
       }
+      let ofm = path.appending(component: "ofm.json")
+      let inputPathsAndContents: [(AbsolutePath, String)] = [(main, mainFileContent)]
+      OutputFileMapCreator.write(
+        module: "Test", inputPaths: inputPathsAndContents.map {$0.0},
+        derivedData: path, to: ofm, excludeMainEntry: false)
+
+      let cHeadersPath: AbsolutePath =
+          try testInputsPath.appending(component: "ExplicitModuleBuilds")
+                            .appending(component: "CHeaders")
+      let swiftModuleInterfacesPath: AbsolutePath =
+          try testInputsPath.appending(component: "ExplicitModuleBuilds")
+                            .appending(component: "Swift")
+      let sdkArgumentsForTesting = (try? Driver.sdkArgumentsForTesting()) ?? []
+      let bridgingHeaderpath: AbsolutePath =
+          cHeadersPath.appending(component: "Bridging.h")
+      var driver = try Driver(args: ["swiftc",
+                                     "-I", cHeadersPath.nativePathString(escaped: true),
+                                     "-I", swiftModuleInterfacesPath.nativePathString(escaped: true),
+                                     "-explicit-module-build", "-Rcache-compile-job", "-incremental",
+                                     "-module-cache-path", moduleCachePath.nativePathString(escaped: true),
+                                     "-cache-compile-job", "-cas-path", casPath.nativePathString(escaped: true),
+                                     "-import-objc-header", bridgingHeaderpath.nativePathString(escaped: true),
+                                     "-output-file-map", ofm.nativePathString(escaped: true),
+                                     "-working-directory", path.nativePathString(escaped: true),
+                                     main.nativePathString(escaped: true)] + sdkArgumentsForTesting,
+                              interModuleDependencyOracle: dependencyOracle)
+      let jobs = try driver.planBuild()
+      try driver.run(jobs: jobs)
+      XCTAssertFalse(driver.diagnosticEngine.hasErrors)
+
+      let scanLibPath = try XCTUnwrap(driver.getSwiftScanLibPath())
+      try dependencyOracle.verifyOrCreateScannerInstance(swiftScanLibPath: scanLibPath)
+
+      let cas = try dependencyOracle.getOrCreateCAS(pluginPath: nil, onDiskPath: casPath, pluginOptions: [])
+      if let driverCAS = driver.cas {
+        XCTAssertEqual(cas, driverCAS, "CAS should only be created once")
+      } else {
+        XCTFail("Cached compilation doesn't have a CAS")
+      }
+      try checkCASForResults(jobs: jobs, cas: cas, fs: driver.fileSystem)
     }
   }