Fix some warnings with ProcessEnvironmentBlock

Package.swift

@@ -350,7 +350,7 @@ let package = Package(
             /** Support for building using Xcode's build system */
             name: "XCBuildSupport",
             dependencies: ["SPMBuildCore", "PackageGraph"],
-            exclude: ["CMakeLists.txt", "CODEOWNERS"]
+            exclude: ["CODEOWNERS"]
         ),
         .target(
             /** High level functionality */

Sources/Basics/Concurrency/ConcurrencyHelpers.swift

@@ -20,7 +20,7 @@ import func TSCBasic.tsc_await
 
 public enum Concurrency {
     public static var maxOperations: Int {
-        ProcessEnv.vars["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
+        ProcessEnv.block["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
             .activeProcessorCount
     }
 }

Sources/Basics/EnvironmentVariables.swift

@@ -11,35 +11,38 @@
 //===----------------------------------------------------------------------===//
 
 import class Foundation.ProcessInfo
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
+import enum TSCBasic.ProcessEnv
 
-public typealias EnvironmentVariables = [String: String]
+public typealias EnvironmentVariables = ProcessEnvironmentBlock
 
 extension EnvironmentVariables {
     public static func empty() -> EnvironmentVariables {
         [:]
     }
 
     public static func process() -> EnvironmentVariables {
-        ProcessInfo.processInfo.environment
+        ProcessEnv.block
     }
 
-    public mutating func prependPath(_ key: String, value: String) {
+    public mutating func prependPath(_ key: ProcessEnvironmentKey, value: String) {
         var values = value.isEmpty ? [] : [value]
         if let existing = self[key], !existing.isEmpty {
             values.append(existing)
         }
         self.setPath(key, values)
     }
 
-    public mutating func appendPath(_ key: String, value: String) {
+    public mutating func appendPath(_ key: ProcessEnvironmentKey, value: String) {
         var values = value.isEmpty ? [] : [value]
         if let existing = self[key], !existing.isEmpty {
             values.insert(existing, at: 0)
         }
         self.setPath(key, values)
     }
 
-    private mutating func setPath(_ key: String, _ values: [String]) {
+    private mutating func setPath(_ key: ProcessEnvironmentKey, _ values: [String]) {
         #if os(Windows)
         let delimiter = ";"
         #else
@@ -50,12 +53,7 @@ extension EnvironmentVariables {
 
     /// `PATH` variable in the process's environment (`Path` under Windows).
     public var path: String? {
-        #if os(Windows)
-        let pathArg = "Path"
-        #else
-        let pathArg = "PATH"
-        #endif
-        return self[pathArg]
+        ProcessEnv.path
     }
 }
 
@@ -64,7 +62,7 @@ extension EnvironmentVariables {
 // rdar://107029374
 extension EnvironmentVariables {
     // internal for testing
-    static let nonCachableKeys: Set<String> = [
+    static let nonCachableKeys: Set<ProcessEnvironmentKey> = [
         "TERM",
         "TERM_PROGRAM",
         "TERM_PROGRAM_VERSION",

Sources/Basics/ImportScanning.swift

@@ -46,7 +46,7 @@ public struct SwiftcImportScanner: ImportScanner {
                    filePathToScan.pathString,
                    "-scan-dependencies", "-Xfrontend", "-import-prescan"] + self.swiftCompilerFlags
 
-        let result = try await TSCBasic.Process.popen(arguments: cmd, environment: self.swiftCompilerEnvironment)
+        let result = try await TSCBasic.Process.popen(arguments: cmd, environmentBlock: self.swiftCompilerEnvironment)
 
         let stdout = try result.utf8Output()
         return try JSONDecoder.makeWithDefaults().decode(Imports.self, from: stdout).imports

Sources/Build/BuildOperation.swift

@@ -759,7 +759,7 @@ public final class BuildOperation: PackageStructureDelegate, SPMBuildCore.BuildS
                 if !pluginConfiguration.disableSandbox {
                     commandLine = try Sandbox.apply(command: commandLine, fileSystem: self.fileSystem, strictness: .writableTemporaryDirectory, writableDirectories: [pluginResult.pluginOutputDirectory])
                 }
-                let processResult = try Process.popen(arguments: commandLine, environment: command.configuration.environment)
+                let processResult = try Process.popen(arguments: commandLine, environmentBlock: command.configuration.environment)
                 let output = try processResult.utf8Output() + processResult.utf8stderrOutput()
                 if processResult.exitStatus != .terminated(code: 0) {
                     throw StringError("failed: \(command)\n\n\(output)")

Sources/Build/BuildOperationBuildSystemDelegateHandler.swift

@@ -600,7 +600,7 @@ final class PackageStructureCommand: CustomLLBuildCommand {
         var hash = Data()
         hash += try! encoder.encode(self.context.productsBuildParameters)
         hash += try! encoder.encode(self.context.toolsBuildParameters)
-        hash += try! encoder.encode(ProcessEnv.vars)
+        hash += try! encoder.encode(ProcessEnv.block)
         return [UInt8](hash)
     }
 

Sources/Build/BuildPlan/BuildPlan.swift

@@ -95,7 +95,7 @@ extension BuildParameters {
         get throws {
             // FIXME: We use this hack to let swiftpm's functional test use shared
             // cache so it doesn't become painfully slow.
-            if let path = ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"] {
+            if let path = ProcessEnv.block["SWIFTPM_TESTS_MODULECACHE"] {
                 return try AbsolutePath(validating: path)
             }
             return buildPath.appending("ModuleCache")

Sources/Commands/PackageTools/InstalledPackages.swift

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 import ArgumentParser
+import typealias Basics.EnvironmentVariables
 import CoreCommands
 import Foundation
 import PackageModel
@@ -32,7 +33,7 @@ extension SwiftPackageTool {
         func run(_ tool: SwiftTool) throws {
             let swiftpmBinDir = try tool.fileSystem.getOrCreateSwiftPMInstalledBinariesDirectory()
 
-            let env = ProcessInfo.processInfo.environment
+            let env = EnvironmentVariables.process()
 
             if let path = env.path, !path.contains(swiftpmBinDir.pathString), !globalOptions.logging.quiet {
                 tool.observabilityScope.emit(

Sources/Commands/SwiftTestTool.swift

@@ -743,7 +743,7 @@ final class TestRunner {
     // The toolchain to use.
     private let toolchain: UserToolchain
 
-    private let testEnv: [String: String]
+    private let testEnv: EnvironmentVariables
 
     /// ObservabilityScope  to emit diagnostics.
     private let observabilityScope: ObservabilityScope
@@ -777,7 +777,7 @@ final class TestRunner {
         additionalArguments: [String],
         cancellator: Cancellator,
         toolchain: UserToolchain,
-        testEnv: [String: String],
+        testEnv: EnvironmentVariables,
         observabilityScope: ObservabilityScope,
         library: BuildParameters.Testing.Library
     ) {
@@ -835,7 +835,11 @@ final class TestRunner {
                 stdout: outputHandler,
                 stderr: outputHandler
             )
-            let process = TSCBasic.Process(arguments: try args(forTestAt: path), environment: self.testEnv, outputRedirection: outputRedirection)
+            let process = TSCBasic.Process(
+                arguments: try args(forTestAt: path),
+                environmentBlock: self.testEnv,
+                outputRedirection: outputRedirection
+            )
             guard let terminationKey = self.cancellator.register(process) else {
                 return false // terminating
             }

Sources/Commands/Utilities/TestingSupport.swift

@@ -119,7 +119,7 @@ enum TestingSupport {
                 sanitizers: sanitizers
             )
 
-            try TSCBasic.Process.checkNonZeroExit(arguments: args, environment: env)
+            try TSCBasic.Process.checkNonZeroExit(arguments: args, environmentBlock: env)
             // Read the temporary file's content.
             return try swiftTool.fileSystem.readFileContents(AbsolutePath(tempFile.path))
         }

Sources/DriverSupport/SPMSwiftDriverExecutor.swift

@@ -31,11 +31,11 @@ public final class SPMSwiftDriverExecutor: DriverExecutor {
 
     public let resolver: ArgsResolver
     let fileSystem: FileSystem
-    let env: EnvironmentVariables
-    
+    let env: [String: String]
+
     public init(resolver: ArgsResolver,
          fileSystem: FileSystem,
-         env: EnvironmentVariables) {
+         env: [String: String]) {
         self.resolver = resolver
         self.fileSystem = fileSystem
         self.env = env

Sources/LLBuildManifest/LLBuildManifestWriter.swift

@@ -184,12 +184,12 @@ public struct ManifestToolStream {
         }
     }
 
-    public subscript(key: String) -> [String: String] {
+    public subscript(key: String) -> EnvironmentVariables {
         get { fatalError() }
         set {
             self.buffer += "    \(key):\n"
-            for (key, value) in newValue.sorted(by: { $0.key < $1.key }) {
-                self.buffer += "      \(key.asJSON): \(value.asJSON)\n"
+            for (key, value) in newValue.sorted(by: { $0.key.value < $1.key.value }) {
+                self.buffer += "      \(key.value.asJSON): \(value.asJSON)\n"
             }
         }
     }

Sources/PackageLoading/ManifestLoader.swift

@@ -857,7 +857,9 @@ public final class ManifestLoader: ManifestLoaderProtocol {
 
         // FIXME: Workaround for the module cache bug that's been haunting Swift CI
         // <rdar://problem/48443680>
-        let moduleCachePath = try (ProcessEnv.vars["SWIFTPM_MODULECACHE_OVERRIDE"] ?? ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"]).flatMap{ try AbsolutePath(validating: $0) }
+        let moduleCachePath = try (
+            ProcessEnv.block["SWIFTPM_MODULECACHE_OVERRIDE"] ?? ProcessEnv.block["SWIFTPM_TESTS_MODULECACHE"]
+        ).flatMap { try AbsolutePath(validating: $0) }
 
         var cmd: [String] = []
         cmd += [self.toolchain.swiftCompilerPathForManifests.pathString]
@@ -955,7 +957,11 @@ public final class ManifestLoader: ManifestLoaderProtocol {
                     evaluationResult.compilerCommandLine = cmd
 
                     // Compile the manifest.
-                    TSCBasic.Process.popen(arguments: cmd, environment: self.toolchain.swiftCompilerEnvironment, queue: callbackQueue) { result in
+                    TSCBasic.Process.popen(
+                        arguments: cmd,
+                        environmentBlock: self.toolchain.swiftCompilerEnvironment,
+                        queue: callbackQueue
+                    ) { result in
                         dispatchPrecondition(condition: .onQueue(callbackQueue))
 
                         var cleanupIfError = DelayableAction(target: tmpDir, action: cleanupTmpDir)
@@ -1047,14 +1053,14 @@ public final class ManifestLoader: ManifestLoaderProtocol {
                             )
                         }
 
-                        var environment = ProcessEnv.vars
+                        var environment = ProcessEnv.block
                         #if os(Windows)
                         let windowsPathComponent = runtimePath.pathString.replacingOccurrences(of: "/", with: "\\")
                         environment["Path"] = "\(windowsPathComponent);\(environment["Path"] ?? "")"
                         #endif
 
                         let cleanupAfterRunning = cleanupIfError.delay()
-                        TSCBasic.Process.popen(arguments: cmd, environment: environment, queue: callbackQueue) { result in
+                        TSCBasic.Process.popen(arguments: cmd, environmentBlock: environment, queue: callbackQueue) { result in
                             dispatchPrecondition(condition: .onQueue(callbackQueue))
 
                             defer { cleanupAfterRunning.perform() }
@@ -1236,8 +1242,8 @@ extension ManifestLoader {
             stream.send(packageLocation)
             stream.send(manifestContents)
             stream.send(toolsVersion.description)
-            for (key, value) in env.sorted(by: { $0.key > $1.key }) {
-                stream.send(key).send(value)
+            for (key, value) in env.sorted(by: { $0.key.value > $1.key.value }) {
+                stream.send(key.value).send(value)
             }
             stream.send(swiftpmVersion)
             return stream.bytes.sha256Checksum
@@ -1301,6 +1307,6 @@ extension ManifestLoader {
 
 extension ProcessEnv {
     fileprivate static var cachableVars: EnvironmentVariables {
-        Self.vars.cachable
+        Self.block.cachable
     }
 }

Sources/PackageLoading/PkgConfig.swift

@@ -126,7 +126,7 @@ public struct PkgConfig {
 
     private static var envSearchPaths: [AbsolutePath] {
         get throws {
-            if let configPath = ProcessEnv.vars["PKG_CONFIG_PATH"] {
+            if let configPath = ProcessEnv.block["PKG_CONFIG_PATH"] {
                 #if os(Windows)
                 return try configPath.split(separator: ";").map({ try AbsolutePath(validating: String($0)) })
                 #else
@@ -183,7 +183,7 @@ internal struct PkgConfigParser {
         variables["pcfiledir"] = pcFile.parentDirectory.pathString
 
         // Add pc_sysrootdir variable. This is the path of the sysroot directory for pc files.
-        variables["pc_sysrootdir"] = ProcessEnv.vars["PKG_CONFIG_SYSROOT_DIR"] ?? AbsolutePath.root.pathString
+        variables["pc_sysrootdir"] = ProcessEnv.block["PKG_CONFIG_SYSROOT_DIR"] ?? AbsolutePath.root.pathString
 
         let fileContents: String = try fileSystem.readFileContents(pcFile)
         for line in fileContents.components(separatedBy: "\n") {

Sources/PackageModel/SwiftSDKs/SwiftSDK.swift

@@ -15,6 +15,7 @@ import Foundation
 
 import class TSCBasic.Process
 import enum TSCBasic.ProcessEnv
+import typealias TSCBasic.ProcessEnvironmentBlock
 
 import struct TSCUtility.Version
 
@@ -446,29 +447,19 @@ public struct SwiftSDK: Equatable {
         return try AbsolutePath(validating: CommandLine.arguments[0], relativeTo: cwd).parentDirectory
     }
 
-    /// The Swift SDK describing the host platform.
-    @available(*, deprecated, renamed: "hostSwiftSDK")
-    public static func hostDestination(
-        _ binDir: AbsolutePath? = nil,
-        originalWorkingDirectory: AbsolutePath? = nil,
-        environment: [String: String] = ProcessEnv.vars
-    ) throws -> SwiftSDK {
-        try self.hostSwiftSDK(binDir, originalWorkingDirectory: originalWorkingDirectory, environment: environment)
-    }
-
     /// The Swift SDK for the host platform.
     public static func hostSwiftSDK(
         _ binDir: AbsolutePath? = nil,
         originalWorkingDirectory: AbsolutePath? = nil,
-        environment: [String: String] = ProcessEnv.vars,
+        environment: ProcessEnvironmentBlock = ProcessEnv.block,
         observabilityScope: ObservabilityScope? = nil
     ) throws -> SwiftSDK {
         let originalWorkingDirectory = originalWorkingDirectory ?? localFileSystem.currentWorkingDirectory
         // Select the correct binDir.
-        if ProcessEnv.vars["SWIFTPM_CUSTOM_BINDIR"] != nil {
+        if ProcessEnv.block["SWIFTPM_CUSTOM_BINDIR"] != nil {
             print("SWIFTPM_CUSTOM_BINDIR was deprecated in favor of SWIFTPM_CUSTOM_BIN_DIR")
         }
-        let customBinDir = (ProcessEnv.vars["SWIFTPM_CUSTOM_BIN_DIR"] ?? ProcessEnv.vars["SWIFTPM_CUSTOM_BINDIR"])
+        let customBinDir = (ProcessEnv.block["SWIFTPM_CUSTOM_BIN_DIR"] ?? ProcessEnv.block["SWIFTPM_CUSTOM_BINDIR"])
             .flatMap { try? AbsolutePath(validating: $0) }
         let binDir = try customBinDir ?? binDir ?? SwiftSDK.hostBinDir(
             fileSystem: localFileSystem,
@@ -478,13 +469,13 @@ public struct SwiftSDK: Equatable {
         let sdkPath: AbsolutePath?
         #if os(macOS)
         // Get the SDK.
-        if let value = ProcessEnv.vars["SDKROOT"] {
+        if let value = ProcessEnv.block["SDKROOT"] {
             sdkPath = try AbsolutePath(validating: value)
         } else {
             // No value in env, so search for it.
             let sdkPathStr = try TSCBasic.Process.checkNonZeroExit(
                 arguments: ["/usr/bin/xcrun", "--sdk", "macosx", "--show-sdk-path"],
-                environment: environment
+                environmentBlock: environment
             ).spm_chomp()
             guard !sdkPathStr.isEmpty else {
                 throw SwiftSDKError.invalidInstallation("default SDK not found")
@@ -541,7 +532,7 @@ public struct SwiftSDK: Equatable {
         }
         let platformPath = try TSCBasic.Process.checkNonZeroExit(
             arguments: ["/usr/bin/xcrun", "--sdk", "macosx", "--show-sdk-platform-path"],
-            environment: environment
+            environmentBlock: environment
         ).spm_chomp()
 
         guard !platformPath.isEmpty else {

Sources/PackageModel/UserToolchain.swift

@@ -14,6 +14,7 @@ import Basics
 import Foundation
 
 import class TSCBasic.Process
+import struct TSCBasic.ProcessEnvironmentKey
 
 #if os(Windows)
 private let hostExecutableSuffix = ".exe"
@@ -117,7 +118,7 @@ public final class UserToolchain: Toolchain {
         searchPaths: [AbsolutePath],
         environment: EnvironmentVariables
     ) -> AbsolutePath? {
-        lookupExecutablePath(filename: environment[variable], searchPaths: searchPaths)
+        lookupExecutablePath(filename: environment[.init(variable)], searchPaths: searchPaths)
     }
 
     private static func getTool(_ name: String, binDirectories: [AbsolutePath]) throws -> AbsolutePath {
@@ -755,7 +756,7 @@ public final class UserToolchain: Toolchain {
     private static func derivePluginServerPath(triple: Triple) throws -> AbsolutePath? {
         if triple.isDarwin() {
             let pluginServerPathFindArgs = ["/usr/bin/xcrun", "--find", "swift-plugin-server"]
-            if let path = try? TSCBasic.Process.checkNonZeroExit(arguments: pluginServerPathFindArgs, environment: [:])
+            if let path = try? TSCBasic.Process.checkNonZeroExit(arguments: pluginServerPathFindArgs, environmentBlock: [:])
                 .spm_chomp() {
                 return try AbsolutePath(validating: path)
             }
@@ -772,7 +773,7 @@ public final class UserToolchain: Toolchain {
         if triple.isDarwin() {
             // XCTest is optional on macOS, for example when Xcode is not installed
             let xctestFindArgs = ["/usr/bin/xcrun", "--sdk", "macosx", "--find", "xctest"]
-            if let path = try? TSCBasic.Process.checkNonZeroExit(arguments: xctestFindArgs, environment: environment)
+            if let path = try? TSCBasic.Process.checkNonZeroExit(arguments: xctestFindArgs, environmentBlock: environment)
                 .spm_chomp()
             {
                 return try AbsolutePath(validating: path)

Sources/SPMBuildCore/BuildSystem/BuildSystem.swift

@@ -175,8 +175,8 @@ public enum BuildSystemUtilities {
     /// Returns the build path from the environment, if present.
     public static func getEnvBuildPath(workingDir: AbsolutePath) throws -> AbsolutePath? {
         // Don't rely on build path from env for SwiftPM's own tests.
-        guard ProcessEnv.vars["SWIFTPM_TESTS_MODULECACHE"] == nil else { return nil }
-        guard let env = ProcessEnv.vars["SWIFTPM_BUILD_DIR"] else { return nil }
+        guard ProcessEnv.block["SWIFTPM_TESTS_MODULECACHE"] == nil else { return nil }
+        guard let env = ProcessEnv.block["SWIFTPM_BUILD_DIR"] else { return nil }
         return try AbsolutePath(validating: env, relativeTo: workingDir)
     }
 }