[Explicit Module Builds] Rely on Clang dependencies' ContextHash to determine the PCM output filename

The driver previously implemented a scheme where it computed an output path for the PCMs of clang module dependencies by hashing the command-line used to build the PCM plus a set of special arguments determined by the depending Swift module that made the PCM unique to the depending Swift module in the build graph. This was previously done first and foremost to accomodate the fact that we used to have Clang modules built against different target triples in the build graph.

The driver would previously execute a dependency scan, and follow it up with a re-scan of relevant clang modules which we require to have dependency info about at a target triple that is different from the main module's target triple. With the introduction of '-clang-target', we are aiming to ensure that '-target' triple of all Clang modules built matches that of the top-level Swift main module being built; therefore, making re-scanning and manual hashing of the PCM output filename unnecessary.

Author: artemcm

Sources/SwiftDriver/ExplicitModuleBuilds/ExplicitDependencyBuildPlanner.swift

@@ -230,18 +230,14 @@ public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalT
                                               commandLine: &commandLine)
 
         let moduleMapPath = moduleDetails.moduleMapPath.path
-        // Encode the target triple pcm args into the output `.pcm` filename
-        let targetEncodedModulePath =
-          try targetEncodedClangModuleFilePath(for: moduleInfo,
-                                               hashParts: getPCMHashParts(pcmArgs: pcmArgs,
-                                                                          contextHash: moduleDetails.contextHash))
-        outputs.append(TypedVirtualPath(file: targetEncodedModulePath, type: .pcm))
+        let modulePCMPath = moduleInfo.modulePath
+        outputs.append(TypedVirtualPath(file: modulePCMPath.path, type: .pcm))
         commandLine.appendFlags("-emit-pcm", "-module-name", moduleId.moduleName,
-                                "-o", targetEncodedModulePath.description)
+                                "-o", modulePCMPath.path.description)
 
         // Fixup "-o -Xcc '<replace-me>'"
         if let outputIndex = commandLine.firstIndex(of: .flag("<replace-me>")) {
-          commandLine[outputIndex] = .path(VirtualPath.lookup(targetEncodedModulePath))
+          commandLine[outputIndex] = .path(VirtualPath.lookup(modulePCMPath.path))
         }
 
         // The only required input is the .modulemap for this module.
@@ -300,21 +296,23 @@ public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalT
       let clangModulePath =
         TypedVirtualPath(file: moduleArtifactInfo.modulePath.path,
                          type: .pcm)
+      let clangModuleMapPath =
+        TypedVirtualPath(file: moduleArtifactInfo.moduleMapPath.path,
+                         type: .clangModuleMap)
+      inputs.append(clangModulePath)
+      inputs.append(clangModuleMapPath)
+
       // If an existing dependency module path stub exists, replace it.
       if let existingIndex = commandLine.firstIndex(of: .flag("-fmodule-file=" + moduleArtifactInfo.moduleName + "=<replace-me>")) {
         commandLine[existingIndex] = .flag("-fmodule-file=\(moduleArtifactInfo.moduleName)=\(clangModulePath.file.description)")
-      } else {
+      } else if case .swift(_) = moduleId {
         commandLine.appendFlags("-Xcc",
                                 "-fmodule-file=\(moduleArtifactInfo.moduleName)=\(clangModulePath.file.description)")
       }
-      
-      let clangModuleMapPath =
-        TypedVirtualPath(file: moduleArtifactInfo.moduleMapPath.path,
-                         type: .clangModuleMap)
-      commandLine.appendFlags("-Xcc",
-                              "-fmodule-map-file=\(clangModuleMapPath.file.description)")
-      inputs.append(clangModulePath)
-      inputs.append(clangModuleMapPath)
+      if case .swift(_) = moduleId {
+        commandLine.appendFlags("-Xcc",
+                                "-fmodule-map-file=\(clangModuleMapPath.file.description)")
+      }
     }
   }
 
@@ -346,14 +344,10 @@ public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalT
           let dependencyInfo = try dependencyGraph.moduleInfo(of: dependencyId)
           let dependencyClangModuleDetails =
             try dependencyGraph.clangModuleDetails(of: dependencyId)
-          let clangModulePath =
-            try targetEncodedClangModuleFilePath(for: dependencyInfo,
-                                                 hashParts: getPCMHashParts(pcmArgs: pcmArgs,
-                                                                            contextHash: dependencyClangModuleDetails.contextHash))
           // Accumulate the required information about this dependency
           clangDependencyArtifacts.append(
             ClangModuleArtifactInfo(name: dependencyId.moduleName,
-                                    modulePath: TextualVirtualPath(path: clangModulePath),
+                                    modulePath: TextualVirtualPath(path: dependencyInfo.modulePath.path),
                                     moduleMapPath: dependencyClangModuleDetails.moduleMapPath))
         case .swiftPrebuiltExternal:
           let prebuiltModuleDetails = try dependencyGraph.swiftPrebuiltDetails(of: dependencyId)
@@ -435,41 +429,6 @@ public typealias ExternalTargetModuleDetailsMap = [ModuleDependencyId: ExternalT
   }
 }
 
-/// Utility methods for encoding PCM's target triple into its name.
-extension ExplicitDependencyBuildPlanner {
-  /// Compute a full path to the resulting .pcm file for a given Clang module, with the
-  /// target triple encoded in the name.
-  public mutating func targetEncodedClangModuleFilePath(for moduleInfo: ModuleInfo,
-                                                        hashParts: [String]) throws -> VirtualPath.Handle {
-    let plainModulePath = VirtualPath.lookup(moduleInfo.modulePath.path)
-    let targetEncodedBaseName =
-      try targetEncodedClangModuleName(for: plainModulePath.basenameWithoutExt,
-                                       hashParts: hashParts)
-    let modifiedModulePath =
-      moduleInfo.modulePath.path.description
-        .replacingOccurrences(of: plainModulePath.basenameWithoutExt,
-                              with: targetEncodedBaseName)
-    return try VirtualPath.intern(path: modifiedModulePath)
-  }
-
-  /// Compute the name of a given Clang module, along with a hash of extra PCM build arguments it
-  /// is to be constructed with.
-  @_spi(Testing) public mutating func targetEncodedClangModuleName(for moduleName: String,
-                                                          hashParts: [String])
-  throws -> String {
-    let hashInput = hashParts.sorted().joined()
-    // Hash based on "moduleName + hashInput"
-    let cacheQuery = moduleName + hashInput
-    if let previouslyHashsedName = hashedModuleNameCache[cacheQuery] {
-      return previouslyHashsedName
-    }
-    let hashedArguments = SHA256().hash(hashInput).hexadecimalRepresentation
-    let resultingName = moduleName + "-" + hashedArguments
-    hashedModuleNameCache[cacheQuery] = resultingName
-    return resultingName
-  }
-}
-
 /// Encapsulates some of the common queries of the ExplicitDependencyBuildPlanner with error-checking
 /// on the dependency graph's structure.
 @_spi(Testing) public extension InterModuleDependencyGraph {

Sources/SwiftDriver/Jobs/Planning.swift

@@ -647,7 +647,8 @@ extension Driver {
     }
 
     // Re-scan Clang modules at all the targets they will be built against.
-    try resolveVersionedClangDependencies(dependencyGraph: &dependencyGraph)
+    // This is currently disabled because we are investigating it being unnecessary
+    // try resolveVersionedClangDependencies(dependencyGraph: &dependencyGraph)
 
     // Set dependency modules' paths to be saved in the module cache.
     try resolveDependencyModulePaths(dependencyGraph: &dependencyGraph)
@@ -676,28 +677,31 @@ extension Driver {
                                                             moduleCachePath: moduleCachePath)
     }
 
-    // For Swift module dependencies, set the output path to include
-    // the module's context hash
-    try resolveSwiftDependencyModuleFileNames(dependencyGraph: &dependencyGraph)
+    // Set the output path to include the module's context hash
+    try resolveDependencyModuleFileNamesWithContextHash(dependencyGraph: &dependencyGraph)
   }
 
   /// For Swift module dependencies, set the output path to include the module's context hash
-  private mutating func resolveSwiftDependencyModuleFileNames(dependencyGraph: inout InterModuleDependencyGraph)
+  private mutating func resolveDependencyModuleFileNamesWithContextHash(dependencyGraph: inout InterModuleDependencyGraph)
   throws {
     for (moduleId, moduleInfo) in dependencyGraph.modules {
       // Output path on the main module is determined by the invocation arguments.
       guard moduleId.moduleName != dependencyGraph.mainModuleName else {
         continue
       }
-      guard case .swift(let swiftDetails) = moduleInfo.details else {
-        continue
-      }
-      guard let contextHash = swiftDetails.contextHash else {
-        throw Driver.Error.missingContextHashOnSwiftDependency(moduleId.moduleName)
-      }
+
       let plainPath = VirtualPath.lookup(dependencyGraph.modules[moduleId]!.modulePath.path)
-      let updatedPath = plainPath.parentDirectory.appending(component: "\(plainPath.basenameWithoutExt)-\(contextHash).\(plainPath.extension!)")
-      dependencyGraph.modules[moduleId]!.modulePath = TextualVirtualPath(path: updatedPath.intern())
+      if case .swift(let swiftDetails) = moduleInfo.details {
+        guard let contextHash = swiftDetails.contextHash else {
+          throw Driver.Error.missingContextHashOnSwiftDependency(moduleId.moduleName)
+        }
+        let updatedPath = plainPath.parentDirectory.appending(component: "\(plainPath.basenameWithoutExt)-\(contextHash).\(plainPath.extension!)")
+        dependencyGraph.modules[moduleId]!.modulePath = TextualVirtualPath(path: updatedPath.intern())
+      } else if case .clang(let clangDetails) = moduleInfo.details {
+        let contextHash = clangDetails.contextHash
+        let updatedPath = plainPath.parentDirectory.appending(component: "\(plainPath.basenameWithoutExt)-\(contextHash).\(plainPath.extension!)")
+        dependencyGraph.modules[moduleId]!.modulePath = TextualVirtualPath(path: updatedPath.intern())
+      }
     }
   }