Merge pull request #235 from artemcm/RevertCompilerBreakers

artemcm · web-flow · commit 7a441561a176 · 2020-09-01T17:45:17.000-07:00
Revert #225 and #234
diff --git a/Sources/SwiftDriver/CMakeLists.txt b/Sources/SwiftDriver/CMakeLists.txt
@@ -13,7 +13,7 @@ add_library(SwiftDriver
   "Explicit Module Builds/ClangVersionedDependencyResolution.swift"
   "Explicit Module Builds/InterModuleDependencyGraph.swift"
   "Explicit Module Builds/ModuleDependencyScanning.swift"
-  "Explicit Module Builds/SerializableModuleArtifacts.swift"
+  "Explicit Module Builds/ModuleArtifacts.swift"
 
   Driver/CompilerMode.swift
   Driver/DebugInfo.swift
diff --git a/Sources/SwiftDriver/Execution/DriverExecutor.swift b/Sources/SwiftDriver/Execution/DriverExecutor.swift
@@ -51,7 +51,15 @@ extension DriverExecutor {
                              recordedInputModificationDates: recordedInputModificationDates)
     
     if (result.exitStatus != .terminated(code: EXIT_SUCCESS)) {
-      let returnCode = Self.computeReturnCode(exitStatus: result.exitStatus)
+      let returnCode: Int
+      switch result.exitStatus {
+      case .terminated(let code):
+        returnCode = Int(code)
+#if !os(Windows)
+      case .signalled(let signal):
+        returnCode = Int(signal)
+#endif
+      }
       throw JobExecutionError.jobFailedWithNonzeroExitCode(returnCode, try result.utf8stderrOutput())
     }
     guard let outputData = try? Data(result.utf8Output().utf8) else {
@@ -60,19 +68,6 @@ extension DriverExecutor {
     
     return try JSONDecoder().decode(outputType, from: outputData)
   }
-
-  static func computeReturnCode(exitStatus: ProcessResult.ExitStatus) -> Int {
-    var returnCode: Int
-    switch exitStatus {
-      case .terminated(let code):
-        returnCode = Int(code)
-      #if !os(Windows)
-      case .signalled(let signal):
-        returnCode = Int(signal)
-      #endif
-    }
-    return returnCode
-  }
 }
 
 public protocol JobExecutionDelegate {
diff --git a/Sources/SwiftDriver/Explicit Module Builds/ClangVersionedDependencyResolution.swift b/Sources/SwiftDriver/Explicit Module Builds/ClangVersionedDependencyResolution.swift
@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-import TSCBasic
 
 /// A map from a module identifier to a set of module dependency graphs
 /// Used to compute distinct graphs corresponding to different target versions for a given clang module
@@ -31,31 +30,19 @@ internal extension Driver {
     // to all Clang modules, and compute a set of distinct PCMArgs across all paths to a
     // given Clang module in the graph.
     let modulePCMArgsSetMap = try dependencyGraph.computePCMArgSetsForClangModules()
-    let temporaryDirectory = try determineTempDirectory()
-    let batchScanInputList =
-      try modulePCMArgsSetMap.compactMap { (moduleId, pcmArgsSet) throws -> [BatchScanModuleInfo] in
-        var moduleInfos: [BatchScanModuleInfo] = []
-        for pcmArgs in pcmArgsSet {
-          var hasher = Hasher()
-          pcmArgs.forEach { hasher.combine($0) }
-          // Generate a filepath for the output dependency graph
-          let moduleDependencyGraphPath =
-            temporaryDirectory.appending(component: moduleId.moduleName +
-                                          String(hasher.finalize()) +
-                                          "-dependencies.json")
-          let moduleBatchInfo =
-            BatchScanModuleInfo.clang(
-              BatchScanClangModuleInfo(moduleName: moduleId.moduleName,
-                                       pcmArgs: pcmArgs.joined(separator: " "),
-                                       outputPath: moduleDependencyGraphPath.description))
-          moduleInfos.append(moduleBatchInfo)
+    var moduleVersionedGraphMap: [ModuleDependencyId: [InterModuleDependencyGraph]] = [:]
+    for (moduleId, pcmArgSet) in modulePCMArgsSetMap {
+      for pcmArgs in pcmArgSet {
+        let pcmSpecificDepGraph = try scanClangModule(moduleId: moduleId,
+                                                      pcmArgs: pcmArgs)
+        if moduleVersionedGraphMap[moduleId] != nil {
+          moduleVersionedGraphMap[moduleId]!.append(pcmSpecificDepGraph)
+        } else {
+          moduleVersionedGraphMap[moduleId] = [pcmSpecificDepGraph]
         }
-        return moduleInfos
-      }.reduce([], +)
+      }
+    }
 
-    // Batch scan all clang modules for each discovered unique set of PCMArgs, per module
-    let moduleVersionedGraphMap: [ModuleDependencyId: [InterModuleDependencyGraph]] =
-      try performBatchDependencyScan(moduleInfos: batchScanInputList)
     try dependencyGraph.resolveVersionedClangModules(using: moduleVersionedGraphMap)
   }
 }
diff --git a/Sources/SwiftDriver/Explicit Module Builds/ModuleArtifacts.swift b/Sources/SwiftDriver/Explicit Module Builds/ModuleArtifacts.swift
@@ -16,7 +16,7 @@ import Foundation
 /// - Swift Module Path
 /// - Swift Doc Path
 /// - Swift Source Info Path
-@_spi(Testing) public struct SwiftModuleArtifactInfo: Codable {
+public struct SwiftModuleArtifactInfo: Codable {
   /// The module's name
   public let moduleName: String
   /// The path for the module's .swiftmodule file
@@ -42,7 +42,7 @@ import Foundation
 /// - Clang Module (name)
 /// - Clang Module (PCM) Path
 /// - Clang Module Map Path
-@_spi(Testing) public struct ClangModuleArtifactInfo: Codable {
+public struct ClangModuleArtifactInfo {
   /// The module's name
   public let moduleName: String
   /// The path for the module's .pcm file
@@ -56,46 +56,3 @@ import Foundation
     self.moduleMapPath = moduleMapPath
   }
 }
-
-/// Describes a given module's batch dependency scanning input info
-/// - Module Name
-/// - Extra PCM build arguments (for Clang modules only)
-/// - Dependency graph output path
-internal enum BatchScanModuleInfo: Encodable {
-  case swift(BatchScanSwiftModuleInfo)
-  case clang(BatchScanClangModuleInfo)
-}
-
-internal struct BatchScanSwiftModuleInfo: Encodable {
-  var swiftModuleName: String
-  var output: String
-
-  init(moduleName: String, outputPath: String) {
-    self.swiftModuleName = moduleName
-    self.output = outputPath
-  }
-}
-
-internal struct BatchScanClangModuleInfo: Encodable {
-  var clangModuleName: String
-  var arguments: String
-  var output: String
-
-  init(moduleName: String, pcmArgs: String, outputPath: String) {
-    self.clangModuleName = moduleName
-    self.arguments = pcmArgs
-    self.output = outputPath
-  }
-}
-
-internal extension BatchScanModuleInfo {
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.singleValueContainer()
-    switch self {
-      case .swift(let swiftInfo):
-        try container.encode(swiftInfo)
-      case .clang(let clangInfo):
-        try container.encode(clangInfo)
-    }
-  }
-}
diff --git a/Sources/SwiftDriver/Explicit Module Builds/ModuleDependencyScanning.swift b/Sources/SwiftDriver/Explicit Module Builds/ModuleDependencyScanning.swift
@@ -24,6 +24,9 @@ extension Driver {
     var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
     commandLine.appendFlag("-frontend")
     commandLine.appendFlag("-scan-dependencies")
+    if parsedOptions.hasArgument(.parseStdlib) {
+       commandLine.appendFlag(.disableObjcAttrRequiresFoundationModule)
+    }
     try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs,
                                  bridgingHeaderHandling: .precompiled,
                                  moduleDependencyGraphUse: .dependencyScan)
@@ -72,105 +75,65 @@ extension Driver {
     return placeholderMapFilePath
   }
 
-  mutating func performBatchDependencyScan(moduleInfos: [BatchScanModuleInfo])
-  throws -> [ModuleDependencyId: [InterModuleDependencyGraph]] {
-    let batchScanningJob = try batchDependencyScanningJob(for: moduleInfos)
-    let forceResponseFiles = parsedOptions.hasArgument(.driverForceResponseFiles)
-    let batchScanResult =
-      try self.executor.execute(job: batchScanningJob,
-                                forceResponseFiles: forceResponseFiles,
-                                recordedInputModificationDates: recordedInputModificationDates)
-    let success = batchScanResult.exitStatus == .terminated(code: EXIT_SUCCESS)
-    guard success else {
-      throw JobExecutionError.jobFailedWithNonzeroExitCode(
-        SwiftDriverExecutor.computeReturnCode(exitStatus: batchScanResult.exitStatus),
-        try batchScanResult.utf8stderrOutput())
-    }
-
-    // Decode the resulting dependency graphs and build a dictionary from a moduleId to
-    // a set of dependency graphs that were built for it
-    let moduleVersionedGraphMap =
-      try moduleInfos.reduce(into: [ModuleDependencyId: [InterModuleDependencyGraph]]()) {
-      let moduleId: ModuleDependencyId
-      let dependencyGraphPath: VirtualPath
-      switch $1 {
-        case .swift(let swiftModuleBatchScanInfo):
-          moduleId = .swift(swiftModuleBatchScanInfo.swiftModuleName)
-          dependencyGraphPath = try VirtualPath(path: swiftModuleBatchScanInfo.output)
-        case .clang(let clangModuleBatchScanInfo):
-          moduleId = .clang(clangModuleBatchScanInfo.clangModuleName)
-          dependencyGraphPath = try VirtualPath(path: clangModuleBatchScanInfo.output)
-      }
-      let contents = try fileSystem.readFileContents(dependencyGraphPath)
-      let decodedGraph = try JSONDecoder().decode(InterModuleDependencyGraph.self,
-                                            from: Data(contents.contents))
-      if $0[moduleId] != nil {
-        $0[moduleId]!.append(decodedGraph)
-      } else {
-        $0[moduleId] = [decodedGraph]
-      }
-    }
-    return moduleVersionedGraphMap
-  }
-
-  /// Precompute the dependencies for a given collection of modules using swift frontend's batch scanning mode
-  mutating func batchDependencyScanningJob(for moduleInfos: [BatchScanModuleInfo]) throws -> Job {
+  /// Compute the dependencies for a given Clang module, by invoking the Clang dependency scanning action
+  /// with the given module's name and a set of arguments (including the target version)
+  mutating func clangDependencyScanningJob(moduleId: ModuleDependencyId,
+                                           pcmArgs: [String]) throws -> Job {
     var inputs: [TypedVirtualPath] = []
 
     // Aggregate the fast dependency scanner arguments
     var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
     commandLine.appendFlag("-frontend")
-    // The dependency scanner automatically operates in batch mode if -batch-scan-input-file
-    // is present.
-    commandLine.appendFlag("-scan-dependencies")
+    commandLine.appendFlag("-scan-clang-dependencies")
+
     try addCommonFrontendOptions(commandLine: &commandLine, inputs: &inputs,
                                  bridgingHeaderHandling: .precompiled,
                                  moduleDependencyGraphUse: .dependencyScan)
 
-    let batchScanInputFilePath = try serializeBatchScanningModuleArtifacts(moduleInfos: moduleInfos)
-    commandLine.appendFlag("-batch-scan-input-file")
-    commandLine.appendPath(batchScanInputFilePath)
+    // Ensure the `-target` option is inherited from the dependent Swift module's PCM args
+    if let targetOptionIndex = pcmArgs.firstIndex(of: Option.target.spelling) {
+      // PCM args are formulated as Clang command line options specified with:
+      // -Xcc <option> -Xcc <option_value>
+      assert(pcmArgs.count > targetOptionIndex + 1 && pcmArgs[targetOptionIndex + 1] == "-Xcc")
+      let pcmArgTriple = Triple(pcmArgs[targetOptionIndex + 2])
+      // Override the invocation's default target argument by appending the one extracted from
+      // the pcmArgs
+      commandLine.appendFlag(.target)
+      commandLine.appendFlag(pcmArgTriple.triple)
+    }
+
+    // Add the PCM args specific to this scan
+    pcmArgs.forEach { commandLine.appendFlags($0) }
 
     // This action does not require any input files, but all frontend actions require
     // at least one input so pick any input of the current compilation.
     let inputFile = inputFiles.first { $0.type == .swift }
     commandLine.appendPath(inputFile!.file)
     inputs.append(inputFile!)
 
-    // This job's outputs are defined as a set of dependency graph json files
-    let outputs: [TypedVirtualPath] = try moduleInfos.map {
-      switch $0 {
-        case .swift(let swiftModuleBatchScanInfo):
-          return TypedVirtualPath(file: try VirtualPath(path: swiftModuleBatchScanInfo.output),
-                                  type: .jsonDependencies)
-        case .clang(let clangModuleBatchScanInfo):
-          return TypedVirtualPath(file: try VirtualPath(path: clangModuleBatchScanInfo.output),
-                                  type: .jsonDependencies)
-      }
-    }
-
+    commandLine.appendFlags("-module-name", moduleId.moduleName)
     // Construct the scanning job.
     return Job(moduleName: moduleOutputInfo.name,
-               kind: .scanDependencies,
+               kind: .scanClangDependencies,
                tool: VirtualPath.absolute(try toolchain.getToolPath(.swiftCompiler)),
                commandLine: commandLine,
                displayInputs: inputs,
                inputs: inputs,
-               outputs: outputs,
+               outputs: [TypedVirtualPath(file: .standardOutput, type: .jsonDependencies)],
                supportsResponseFiles: true)
   }
 
-  /// Serialize a collection of modules into an input format expected by the batch module dependency scanner.
-  func serializeBatchScanningModuleArtifacts(moduleInfos: [BatchScanModuleInfo])
-  throws -> AbsolutePath {
-    let temporaryDirectory = try determineTempDirectory()
-    let batchScanInputFilePath =
-      temporaryDirectory.appending(component: "\(moduleOutputInfo.name)-batch-module-scan.json")
+  mutating func scanClangModule(moduleId: ModuleDependencyId, pcmArgs: [String])
+  throws -> InterModuleDependencyGraph {
+    let clangDependencyScannerJob = try clangDependencyScanningJob(moduleId: moduleId,
+                                                                   pcmArgs: pcmArgs)
+    let forceResponseFiles = parsedOptions.hasArgument(.driverForceResponseFiles)
 
-    let encoder = JSONEncoder()
-    encoder.outputFormatting = [.prettyPrinted]
-    let contents = try encoder.encode(moduleInfos)
-    try fileSystem.writeFileContents(batchScanInputFilePath, bytes: ByteString(contents))
-    return batchScanInputFilePath
+    let dependencyGraph =
+      try self.executor.execute(job: clangDependencyScannerJob,
+                                capturingJSONOutputAs: InterModuleDependencyGraph.self,
+                                forceResponseFiles: forceResponseFiles,
+                                recordedInputModificationDates: recordedInputModificationDates)
+    return dependencyGraph
   }
 }
