Merge pull request #1219 from artemcm/ExplicitScanNoReVersion

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

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())
+      }
     }
   }