Replace occurences of the deprecated 'ProcessEnv.vars' with 'ProcessEnv.block'

Author: artemcm

Sources/SwiftDriver/Driver/Driver.swift

@@ -28,6 +28,8 @@ import struct TSCBasic.SHA256
 import var TSCBasic.localFileSystem
 import var TSCBasic.stderrStream
 import var TSCBasic.stdoutStream
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
 
 extension Driver {
   /// Stub Error for terminating the process.
@@ -153,7 +155,7 @@ public struct Driver {
   /// The set of environment variables that are visible to the driver and
   /// processes it launches. This is a hook for testing; in actual use
   /// it should be identical to the real environment.
-  public let env: [String: String]
+  public let env: ProcessEnvironmentBlock
 
   /// Whether we are using the driver as the integrated driver via libSwiftDriver
   public let integratedDriver: Bool
@@ -814,11 +816,44 @@ public struct Driver {
     )
   }
 
+  @available(*, deprecated, renamed: "init(args:envBlock:diagnosticsOutput:fileSystem:executor:integratedDriver:compilerIntegratedTooling:compilerExecutableDir:externalTargetModuleDetailsMap:interModuleDependencyOracle:)")
+  @_disfavoredOverload
+  public init(
+    args: [String],
+    env: [String: String] = ProcessEnv.vars,
+    diagnosticsOutput: DiagnosticsOutput = .engine(DiagnosticsEngine(handlers: [Driver.stderrDiagnosticsHandler])),
+    fileSystem: FileSystem = localFileSystem,
+    executor: DriverExecutor,
+    integratedDriver: Bool = true,
+    compilerIntegratedTooling: Bool = false,
+    compilerExecutableDir: AbsolutePath? = nil,
+    externalTargetModuleDetailsMap: ExternalTargetModuleDetailsMap? = nil,
+    interModuleDependencyOracle: InterModuleDependencyOracle? = nil
+  ) throws {
+    let envBlock = env.reduce([:]) { (partialResult: ProcessEnvironmentBlock, tuple: (key: String, value: String)) in
+      var result = partialResult
+      result[ProcessEnvironmentKey(tuple.key)] = tuple.value
+      return result
+    }
+    try self.init(
+      args: args,
+      envBlock: envBlock,
+      diagnosticsOutput: diagnosticsOutput,
+      fileSystem: fileSystem,
+      executor: executor,
+      integratedDriver: integratedDriver,
+      compilerIntegratedTooling: false,
+      compilerExecutableDir: compilerExecutableDir,
+      externalTargetModuleDetailsMap: externalTargetModuleDetailsMap,
+      interModuleDependencyOracle: interModuleDependencyOracle
+    )
+  }
+
   /// Create the driver with the given arguments.
   ///
   /// - Parameter args: The command-line arguments, including the "swift" or "swiftc"
   ///   at the beginning.
-  /// - Parameter env: The environment variables to use. This is a hook for testing;
+  /// - Parameter envBlock: The environment variables to use. This is a hook for testing;
   ///   in production, you should use the default argument, which copies the current environment.
   /// - Parameter diagnosticsOutput: The diagnostics output implementation used by the driver to emit errors
   ///   and warnings.
@@ -836,7 +871,7 @@ public struct Driver {
   ///   shared across different module builds by a build system.
   public init(
     args: [String],
-    env: [String: String] = ProcessEnv.vars,
+    envBlock: ProcessEnvironmentBlock = ProcessEnv.block,
     diagnosticsOutput: DiagnosticsOutput = .engine(DiagnosticsEngine(handlers: [Driver.stderrDiagnosticsHandler])),
     fileSystem: FileSystem = localFileSystem,
     executor: DriverExecutor,
@@ -845,7 +880,7 @@ public struct Driver {
     compilerExecutableDir: AbsolutePath? = nil,
     interModuleDependencyOracle: InterModuleDependencyOracle? = nil
   ) throws {
-    self.env = env
+    self.env = envBlock
     self.fileSystem = fileSystem
     self.integratedDriver = integratedDriver
     self.compilerIntegratedTooling = compilerIntegratedTooling
@@ -2535,7 +2570,7 @@ extension Driver {
   static func determineNumParallelJobs(
     _ parsedOptions: inout ParsedOptions,
     diagnosticsEngine: DiagnosticsEngine,
-    env: [String: String]
+    env: ProcessEnvironmentBlock
   ) -> Int? {
     guard let numJobs = parseIntOption(&parsedOptions, option: .j, diagnosticsEngine: diagnosticsEngine) else {
       return nil
@@ -3028,7 +3063,7 @@ extension Driver {
     targetTriple: Triple?,
     fileSystem: FileSystem,
     diagnosticsEngine: DiagnosticsEngine,
-    env: [String: String]
+    env: ProcessEnvironmentBlock
   ) -> VirtualPath? {
     var sdkPath: String?
 
@@ -3558,7 +3593,7 @@ extension Driver {
     _ parsedOptions: inout ParsedOptions,
     diagnosticsEngine: DiagnosticsEngine,
     compilerMode: CompilerMode,
-    env: [String: String],
+    env: ProcessEnvironmentBlock,
     executor: DriverExecutor,
     fileSystem: FileSystem,
     useStaticResourceDir: Bool,
@@ -3589,7 +3624,7 @@ extension Driver {
   static func computeTargetInfo(_ parsedOptions: inout ParsedOptions,
                                 diagnosticsEngine: DiagnosticsEngine,
                                 compilerMode: CompilerMode,
-                                env: [String: String],
+                                env: ProcessEnvironmentBlock,
                                 executor: DriverExecutor,
                                 libSwiftScan: SwiftScan?,
                                 toolchain: Toolchain,

Sources/SwiftDriver/Execution/DriverExecutor.swift

@@ -15,6 +15,8 @@ import struct TSCBasic.ProcessResult
 import struct Foundation.Data
 import class Foundation.JSONDecoder
 import var Foundation.EXIT_SUCCESS
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
 
 /// A type that is capable of executing compilation jobs on some underlying
 /// build service.
@@ -205,3 +207,14 @@ public protocol JobExecutionDelegate {
   /// Called when a job is skipped.
   func jobSkipped(job: Job)
 }
+
+@_spi(Testing) public extension ProcessEnvironmentBlock {
+  var legacyVars: [String: String] {
+    return self.reduce([:]) {
+      (partialResult: [String: String], tuple: (key: ProcessEnvironmentKey, value: String)) in
+      var result = partialResult
+      result[tuple.key.value] = tuple.value
+      return result
+    }
+  }
+}

Sources/SwiftDriver/Execution/ProcessProtocol.swift

@@ -12,6 +12,7 @@
 
 import class TSCBasic.Process
 import struct TSCBasic.ProcessResult
+import typealias TSCBasic.ProcessEnvironmentBlock
 
 import class Foundation.FileHandle
 import struct Foundation.Data
@@ -32,17 +33,18 @@ public protocol ProcessProtocol {
 
   static func launchProcess(
     arguments: [String],
-    env: [String: String]
+    env: ProcessEnvironmentBlock
   ) throws -> Self
 
   static func launchProcessAndWriteInput(
     arguments: [String],
-    env: [String: String],
+    env: ProcessEnvironmentBlock,
     inputFileHandle: FileHandle
   ) throws -> Self
 }
 
 extension TSCBasic.Process: ProcessProtocol {
+  @available(*, deprecated, message: "use launchProcess(arguments:envBlock:) instead")
   public static func launchProcess(
     arguments: [String],
     env: [String: String]
@@ -52,12 +54,21 @@ extension TSCBasic.Process: ProcessProtocol {
     return process
   }
 
+  public static func launchProcess(
+    arguments: [String],
+    env: ProcessEnvironmentBlock
+  ) throws -> TSCBasic.Process {
+    let process = Process(arguments: arguments, environmentBlock: env)
+    try process.launch()
+    return process
+  }
+
   public static func launchProcessAndWriteInput(
     arguments: [String],
-    env: [String: String],
+    env: ProcessEnvironmentBlock,
     inputFileHandle: FileHandle
   ) throws -> TSCBasic.Process {
-    let process = Process(arguments: arguments, environment: env)
+    let process = Process(arguments: arguments, environmentBlock: env)
     let processInputStream = try process.launch()
     var input: Data
     // Write out the contents of the input handle and close the input stream

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -16,6 +16,7 @@ import struct TSCBasic.RelativePath
 import struct TSCBasic.Diagnostic
 import var TSCBasic.localFileSystem
 import var TSCBasic.stdoutStream
+import typealias TSCBasic.ProcessEnvironmentBlock
 
 import SwiftOptions
 import struct Foundation.Data
@@ -334,7 +335,7 @@ public extension Driver {
                                             useResponseFiles: useResponseFiles).0.map { $0.spm_shellEscaped() }
   }
 
-  static func getRootPath(of toolchain: Toolchain, env: [String: String])
+  static func getRootPath(of toolchain: Toolchain, env: ProcessEnvironmentBlock)
   throws -> AbsolutePath {
     return try toolchain.getToolPath(.swiftCompiler)
       .parentDirectory // bin

Sources/SwiftDriver/Jobs/DarwinToolchain+LinkerSupport.swift

@@ -19,7 +19,7 @@ extension DarwinToolchain {
   internal func findXcodeClangPath() throws -> AbsolutePath? {
     let result = try executor.checkNonZeroExit(
       args: "xcrun", "-toolchain", "default", "-f", "clang",
-      environment: env
+      environment: env.legacyVars
     ).trimmingCharacters(in: .whitespacesAndNewlines)
 
     return result.isEmpty ? nil : try AbsolutePath(validating: result)

Sources/SwiftDriver/Jobs/EmitSupportedFeaturesJob.swift

@@ -18,6 +18,7 @@ import class TSCBasic.DiagnosticsEngine
 import protocol TSCBasic.FileSystem
 import struct TSCBasic.RelativePath
 import var TSCBasic.localFileSystem
+import typealias TSCBasic.ProcessEnvironmentBlock
 
 /// Describes information about the compiler's supported arguments and features
 @_spi(Testing) public struct SupportedCompilerFeatures: Codable {
@@ -90,7 +91,7 @@ extension Driver {
   }
 
   static func computeSupportedCompilerFeatures(of toolchain: Toolchain,
-                                               env: [String: String]) throws -> Set<String> {
+                                               env: ProcessEnvironmentBlock) throws -> Set<String> {
     struct FeatureInfo: Codable {
       var name: String
     }

Sources/SwiftDriver/Jobs/Job.swift

@@ -12,6 +12,8 @@
 
 import protocol TSCBasic.DiagnosticData
 import protocol TSCBasic.FileSystem
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
 
 /// A job represents an individual subprocess that should be invoked during compilation.
 public struct Job: Codable, Equatable, Hashable {
@@ -93,7 +95,7 @@ public struct Job: Codable, Equatable, Hashable {
   public var outputs: [TypedVirtualPath]
 
   /// Any extra environment variables which should be set while running the job.
-  public var extraEnvironment: [String: String]
+  public var extraEnvironment: ProcessEnvironmentBlock
 
   /// Whether or not the job must be executed in place, replacing the current driver process.
   public var requiresInPlaceExecution: Bool
@@ -118,7 +120,7 @@ public struct Job: Codable, Equatable, Hashable {
     outputs: [TypedVirtualPath],
     outputCacheKeys: [TypedVirtualPath: String] = [:],
     inputOutputMap: [TypedVirtualPath : [TypedVirtualPath]] = [:],
-    extraEnvironment: [String: String] = [:],
+    extraEnvironment: ProcessEnvironmentBlock = [:],
     requiresInPlaceExecution: Bool = false
   ) {
     self.moduleName = moduleName
@@ -131,7 +133,8 @@ public struct Job: Codable, Equatable, Hashable {
     self.outputs = outputs
     self.outputCacheKeys = outputCacheKeys
     self.compileInputOutputMap = inputOutputMap
-    self.extraEnvironment = extraEnvironment
+    self.extraEnvironmentBlock = extraEnvironment
+    self.extraEnvironment = self.extraEnvironmentBlock.legacyVars
     self.requiresInPlaceExecution = requiresInPlaceExecution
     self.supportsResponseFiles = tool.supportsResponseFiles
   }

Sources/SwiftDriver/Jobs/Toolchain+InterpreterSupport.swift

@@ -10,13 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
 import SwiftOptions
 
 extension Toolchain {
   func addPathEnvironmentVariableIfNeeded(
-    _ environmentVariable: String,
-    to env: inout [String : String],
-    currentEnv: [String: String],
+    _ environmentVariable: ProcessEnvironmentKey,
+    to env: inout ProcessEnvironmentBlock,
+    currentEnv: ProcessEnvironmentBlock,
     option: Option,
     parsedOptions: inout ParsedOptions,
     extraPaths: [String] = []
@@ -31,17 +33,17 @@ extension Toolchain {
 
 extension DarwinToolchain {
   public func platformSpecificInterpreterEnvironmentVariables(
-    env: [String : String],
+    env: ProcessEnvironmentBlock,
     parsedOptions: inout ParsedOptions,
     sdkPath: VirtualPath.Handle?,
-    targetInfo: FrontendTargetInfo) throws -> [String: String] {
-    var envVars: [String: String] = [:]
+    targetInfo: FrontendTargetInfo) throws -> ProcessEnvironmentBlock {
+    var envVars: ProcessEnvironmentBlock = [:]
 
-    addPathEnvironmentVariableIfNeeded("DYLD_LIBRARY_PATH", to: &envVars,
+    addPathEnvironmentVariableIfNeeded(ProcessEnvironmentKey("DYLD_LIBRARY_PATH"), to: &envVars,
                                        currentEnv: env, option: .L,
                                        parsedOptions: &parsedOptions)
 
-    addPathEnvironmentVariableIfNeeded("DYLD_FRAMEWORK_PATH", to: &envVars,
+    addPathEnvironmentVariableIfNeeded(ProcessEnvironmentKey("DYLD_FRAMEWORK_PATH"), to: &envVars,
                                        currentEnv: env, option: .F,
                                        parsedOptions: &parsedOptions,
                                        extraPaths: ["/System/Library/Frameworks"])
@@ -52,11 +54,11 @@ extension DarwinToolchain {
 
 extension GenericUnixToolchain {
   public func platformSpecificInterpreterEnvironmentVariables(
-    env: [String : String],
+    env: ProcessEnvironmentBlock,
     parsedOptions: inout ParsedOptions,
     sdkPath: VirtualPath.Handle?,
-    targetInfo: FrontendTargetInfo) throws -> [String: String] {
-    var envVars: [String: String] = [:]
+    targetInfo: FrontendTargetInfo) throws -> ProcessEnvironmentBlock {
+    var envVars: ProcessEnvironmentBlock = [:]
 
     let runtimePaths = try runtimeLibraryPaths(
       for: targetInfo,
@@ -65,7 +67,7 @@ extension GenericUnixToolchain {
       isShared: true
     ).map { $0.name }
 
-    addPathEnvironmentVariableIfNeeded("LD_LIBRARY_PATH", to: &envVars,
+    addPathEnvironmentVariableIfNeeded(ProcessEnvironmentKey("LD_LIBRARY_PATH"), to: &envVars,
                                        currentEnv: env, option: .L,
                                        parsedOptions: &parsedOptions,
                                        extraPaths: runtimePaths)
@@ -76,10 +78,10 @@ extension GenericUnixToolchain {
 
 extension WindowsToolchain {
   public func platformSpecificInterpreterEnvironmentVariables(
-    env: [String : String],
+    env: ProcessEnvironmentBlock,
     parsedOptions: inout ParsedOptions,
     sdkPath: VirtualPath.Handle?,
-    targetInfo: FrontendTargetInfo) throws -> [String: String] {
+    targetInfo: FrontendTargetInfo) throws -> ProcessEnvironmentBlock {
 
     // TODO(compnerd): setting up `Path` is meaningless currently as the lldb
     // support required for the interpreter mode fails to load the dependencies.

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -21,12 +21,14 @@ import class TSCBasic.DiagnosticsEngine
 import struct TSCBasic.AbsolutePath
 import struct TSCBasic.Diagnostic
 import var TSCBasic.localFileSystem
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
 
 /// Toolchain for Darwin-based platforms, such as macOS and iOS.
 ///
 /// FIXME: This class is not thread-safe.
 public final class DarwinToolchain: Toolchain {
-  public let env: [String: String]
+  public let env: ProcessEnvironmentBlock
 
   /// Doubles as path cache and point for overriding normal lookup
   private var toolPaths = [Tool: AbsolutePath]()
@@ -45,7 +47,7 @@ public final class DarwinToolchain: Toolchain {
 
   public let dummyForTestingObjectFormat = Triple.ObjectFormat.macho
 
-  public init(env: [String: String], executor: DriverExecutor, fileSystem: FileSystem = localFileSystem,
+  public init(env: ProcessEnvironmentBlock, executor: DriverExecutor, fileSystem: FileSystem = localFileSystem,
               compilerExecutableDir: AbsolutePath? = nil, toolDirectory: AbsolutePath? = nil) {
     self.env = env
     self.executor = executor
@@ -139,7 +141,7 @@ public final class DarwinToolchain: Toolchain {
     if target?.isMacOSX == true || hostIsMacOS {
       let result = try executor.checkNonZeroExit(
         args: "xcrun", "-sdk", "macosx", "--show-sdk-path",
-        environment: env
+        environment: env.legacyVars
       ).trimmingCharacters(in: .whitespacesAndNewlines)
       return try AbsolutePath(validating: result)
     }