Start adopting the new Environment type throughout the codebase

Mostly starting at the "edges", in tests and in some central APIs. Does nothing for Unix-like platforms, but will fix some case sensitivity issues on Windows when accessing specific environment variables.

Closes #296

Author: jakepetroules

Sources/SWBBuildService/Messages.swift

@@ -184,7 +184,7 @@ extension SetSessionWorkspaceContainerPathRequest: PIFProvidingRequest {
             try fs.createDirectory(dir, recursive: true)
             let pifPath = dir.join(Foundation.UUID().description + ".json")
             let argument = isProject ? "-project" : "-workspace"
-            let result = try await Process.getOutput(url: URL(fileURLWithPath: "/usr/bin/xcrun"), arguments: ["xcodebuild", "-dumpPIF", pifPath.str, argument, path.str], currentDirectoryURL: URL(fileURLWithPath: containerPath.dirname.str, isDirectory: true), environment: ProcessInfo.processInfo.cleanEnvironment.merging(["DEVELOPER_DIR": session.core.developerPath.str], uniquingKeysWith: { _, new in new }))
+            let result = try await Process.getOutput(url: URL(fileURLWithPath: "/usr/bin/xcrun"), arguments: ["xcodebuild", "-dumpPIF", pifPath.str, argument, path.str], currentDirectoryURL: URL(fileURLWithPath: containerPath.dirname.str, isDirectory: true), environment: Environment.current.addingContents(of: [.developerDir: session.core.developerPath.str]))
             if !result.exitStatus.isSuccess {
                 throw StubError.error("Could not dump PIF for '\(path.str)': \(String(decoding: result.stderr, as: UTF8.self))")
             }

Sources/SWBBuildSystem/CleanOperation.swift

@@ -214,10 +214,10 @@ package final class CleanOperation: BuildSystemOperation, TargetDependencyResolv
         let taskIdentifier = task.identifier
         let taskOutputDelegate = delegate.taskStarted(self, taskIdentifier: taskIdentifier, task: task, dependencyInfo: nil)
 
-        let resolvedExecutable = StackedSearchPath(environment: environment, fs: workspaceContext.fs).lookup(Path(executable)) ?? Path(executable)
+        let resolvedExecutable = StackedSearchPath(environment: .init(environment), fs: workspaceContext.fs).lookup(Path(executable)) ?? Path(executable)
 
         do {
-            let result = try await Process.getMergedOutput(url: URL(fileURLWithPath: resolvedExecutable.str), arguments: arguments, currentDirectoryURL: URL(fileURLWithPath: workingDirectory.str), environment: environment)
+            let result = try await Process.getMergedOutput(url: URL(fileURLWithPath: resolvedExecutable.str), arguments: arguments, currentDirectoryURL: URL(fileURLWithPath: workingDirectory.str), environment: .init(environment))
 
             if !result.exitStatus.isSuccess {
                 taskOutputDelegate.emitError("Failed to clean target '\(configuredTarget.target.name)': \(String(decoding: result.output, as: UTF8.self))")

Sources/SWBCore/SWBFeatureFlag.swift

@@ -35,15 +35,15 @@ public struct SWBFeatureFlagProperty {
 
     /// Whether the feature flag is actually set at all.
     public var hasValue: Bool {
-        return SWBUtil.UserDefaults.hasValue(forKey: key) || getEnvironmentVariable(key) != nil
+        return SWBUtil.UserDefaults.hasValue(forKey: key) || getEnvironmentVariable(EnvironmentKey(key)) != nil
     }
 
     /// Indicates whether the feature flag is currently active in the calling environment.
     public var value: Bool {
         if !hasValue {
             return defaultValue
         }
-        return SWBUtil.UserDefaults.bool(forKey: key) || getEnvironmentVariable(key)?.boolValue == true
+        return SWBUtil.UserDefaults.bool(forKey: key) || getEnvironmentVariable(EnvironmentKey(key))?.boolValue == true
     }
 
     fileprivate init(_ key: String, defaultValue: Bool = false) {
@@ -59,7 +59,7 @@ public struct SWBOptionalFeatureFlagProperty {
     /// Returns nil if neither environment variable nor User Default are set.  An implementation can then pick a default behavior.
     /// If both the environment variable and User Default are set, the two values are logically AND'd together; this allows the set false value of either to force the feature flag off.
     public var value: Bool? {
-        let envValue = getEnvironmentVariable(key)
+        let envValue = getEnvironmentVariable(EnvironmentKey(key))
         let envHasValue = envValue != nil
         let defHasValue = SWBUtil.UserDefaults.hasValue(forKey: key)
         if !envHasValue && !defHasValue {

Sources/SWBCore/Settings/StackedSearchPaths.swift

@@ -33,8 +33,8 @@ public final class StackedSearchPath: Sendable {
         self.fs = fs
     }
 
-    public init(environment: [String: String], fs: any FSProxy) {
-        self.paths = environment["PATH"]?.split(separator: Path.pathEnvironmentSeparator).map(Path.init) ?? []
+    public init(environment: Environment, fs: any FSProxy) {
+        self.paths = environment[.path]?.split(separator: Path.pathEnvironmentSeparator).map(Path.init) ?? []
         self.fs = fs
     }
 

Sources/SWBCore/SpecImplementations/CommandLineToolSpec.swift

@@ -1390,7 +1390,7 @@ open class CommandLineToolSpec : PropertyDomainSpec, SpecType, TaskTypeDescripti
     public func executeExternalTool<T>(_ cbc: CommandBuildContext, _ delegate: any TaskGenerationDelegate, commandLine: [String], workingDirectory: String?, environment: [String: String], executionDescription: String?, _ parse: @escaping (ByteString) throws -> T) async throws -> T {
         let executionResult = try await delegate.executeExternalTool(commandLine: commandLine, workingDirectory: workingDirectory, environment: environment, executionDescription: executionDescription)
         guard executionResult.exitStatus.isSuccess else {
-            throw RunProcessNonZeroExitError(args: commandLine, workingDirectory: workingDirectory, environment: environment, status: executionResult.exitStatus, stdout: ByteString(executionResult.stdout), stderr: ByteString(executionResult.stderr))
+            throw RunProcessNonZeroExitError(args: commandLine, workingDirectory: workingDirectory, environment: .init(environment), status: executionResult.exitStatus, stdout: ByteString(executionResult.stdout), stderr: ByteString(executionResult.stderr))
         }
         return try parse(ByteString(executionResult.stdout))
     }

Sources/SWBCore/TaskGeneration.swift

@@ -781,7 +781,7 @@ extension CoreClientDelegate {
             }
 
             return try await externalToolExecutionQueue.withOperation {
-                try await Process.getOutput(url: url, arguments: Array(commandLine.dropFirst()), currentDirectoryURL: workingDirectory.map(URL.init(fileURLWithPath:)), environment: ProcessInfo.processInfo.cleanEnvironment.merging(environment, uniquingKeysWith: { _, new in new }))
+                try await Process.getOutput(url: url, arguments: Array(commandLine.dropFirst()), currentDirectoryURL: workingDirectory.map(URL.init(fileURLWithPath:)), environment: Environment.current.addingContents(of: .init(environment)))
             }
         case let .result(status, stdout, stderr):
             return Processes.ExecutionResult(exitStatus: status, stdout: stdout, stderr: stderr)

Sources/SWBCore/ToolchainRegistry.swift

@@ -472,7 +472,7 @@ public final class ToolchainRegistry: @unchecked Sendable {
             return
         }
 
-        if let swift = StackedSearchPath(environment: ProcessInfo.processInfo.cleanEnvironment, fs: fs).lookup(Path("swift")), fs.exists(swift) {
+        if let swift = StackedSearchPath(environment: .current, fs: fs).lookup(Path("swift")), fs.exists(swift) {
             let hasUsrBin = swift.normalize().str.hasSuffix("/usr/bin/swift")
             let hasUsrLocalBin = swift.normalize().str.hasSuffix("/usr/local/bin/swift")
             let path: Path

Sources/SWBQNXPlatform/Plugin.swift

@@ -46,7 +46,7 @@ struct QNXEnvironmentExtension: EnvironmentExtension {
 
     func additionalEnvironmentVariables(context: any EnvironmentExtensionAdditionalEnvironmentVariablesContext) async throws -> [String : String] {
         if let latest = try await plugin.cachedQNXSDPInstallations(host: context.hostOperatingSystem).first {
-            return latest.environment
+            return .init(latest.environment)
         }
         return [:]
     }

Sources/SWBQNXPlatform/QNXSDP.swift

@@ -28,11 +28,13 @@ struct QNXSDP: Sendable {
         self.sysroot = sysroot
         self.configurationPath = configurationPath
 
-        let environment = [
+        var environment: Environment = [
             "QNX_TARGET": sysroot.str,
-            "QNX_HOST": hostPath?.str,
             "QNX_CONFIGURATION_EXCLUSIVE": configurationPath.str,
-        ].compactMapValues { $0 }
+        ]
+        if let hostPath {
+            environment["QNX_HOST"] = hostPath.str
+        }
         self.environment = environment
 
         self.version = try await {
@@ -60,7 +62,7 @@ struct QNXSDP: Sendable {
     /// Equivalent to `QNX_HOST`.
     public let hostPath: Path?
 
-    public let environment: [String: String]
+    public let environment: Environment
 
     private static func hostPath(host: OperatingSystem, path: Path) -> Path? {
         switch host {

Sources/SWBTaskExecution/TaskActions/EmbedSwiftStdLibTaskAction.swift

@@ -525,7 +525,7 @@ public final class EmbedSwiftStdLibTaskAction: TaskAction {
             }
 
             guard !failed else {
-                throw RunProcessNonZeroExitError(args: args, workingDirectory: task.workingDirectory.str, environment: effectiveEnvironment, status: {
+                throw RunProcessNonZeroExitError(args: args, workingDirectory: task.workingDirectory.str, environment: .init(effectiveEnvironment), status: {
                     if case let .exit(exitStatus, _) = processDelegate.outputDelegate.result {
                         return exitStatus
                     }

Sources/SWBTestSupport/BuildOperationTester.swift

@@ -1918,7 +1918,7 @@ private final class BuildOperationTesterDelegate: BuildOperationDelegate {
                     if !self.hadErrors {
                         switch result {
                         case let .exit(exitStatus, _) where !exitStatus.isSuccess && !exitStatus.wasCanceled:
-                            self.delegate.events.append(.buildHadDiagnostic(Diagnostic(behavior: .error, location: .unknown, data: DiagnosticData("Command \(task.ruleInfo[0]) failed. \(RunProcessNonZeroExitError(args: Array(task.commandLineAsStrings), workingDirectory: task.workingDirectory.str, environment: task.environment.bindingsDictionary, status: exitStatus, mergedOutput: output).description)"))))
+                            self.delegate.events.append(.buildHadDiagnostic(Diagnostic(behavior: .error, location: .unknown, data: DiagnosticData("Command \(task.ruleInfo[0]) failed. \(RunProcessNonZeroExitError(args: Array(task.commandLineAsStrings), workingDirectory: task.workingDirectory.str, environment: .init(task.environment.bindingsDictionary), status: exitStatus, mergedOutput: output).description)"))))
                         case .failedSetup:
                             self.delegate.events.append(.buildHadDiagnostic(Diagnostic(behavior: .error, location: .unknown, data: DiagnosticData("Command \(task.ruleInfo[0]) failed setup."))))
                         case .exit, .skipped:

Sources/SWBTestSupport/EnvironmentKey.swift

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+public import SWBUtil
+
+extension EnvironmentKey {
+    public static let externalToolchainsDir = Self("EXTERNAL_TOOLCHAINS_DIR")
+}

Sources/SWBTestSupport/Misc.swift

@@ -39,7 +39,7 @@ package extension Sequence where Element: Equatable {
 /// - throws: ``StubError`` if the arguments list is an empty array.
 /// - throws: ``RunProcessNonZeroExitError`` if the process exited with a nonzero status code or uncaught signal.
 @discardableResult
-package func runProcess(_ args: [String], workingDirectory: String? = nil, environment: [String: String] = [:], interruptible: Bool = true, redirectStderr: Bool = false) async throws -> String {
+package func runProcess(_ args: [String], workingDirectory: String? = nil, environment: Environment = .init(), interruptible: Bool = true, redirectStderr: Bool = false) async throws -> String {
     guard let first = args.first else {
         throw StubError.error("Invalid number of arguments")
     }
@@ -66,19 +66,18 @@ package func runProcess(_ args: [String], workingDirectory: String? = nil, envir
 ///
 /// This method will use the current value of `DEVELOPER_DIR` in the environment by default, or the value of `overrideDeveloperDirectory` if specified.
 package func runProcessWithDeveloperDirectory(_ args: [String], workingDirectory: String? = nil, overrideDeveloperDirectory: String? = nil, interruptible: Bool = true, redirectStderr: Bool = true) async throws -> String {
-    let environment = ProcessInfo.processInfo.environment
+    let environment = Environment.current
         .filter(keys: ["DEVELOPER_DIR", "LLVM_PROFILE_FILE"])
-        .addingContents(of: overrideDeveloperDirectory.map { ["DEVELOPER_DIR": $0] } ?? [:])
+        .addingContents(of: overrideDeveloperDirectory.map { Environment(["DEVELOPER_DIR": $0]) } ?? .init())
     return try await runProcess(args, workingDirectory: workingDirectory, environment: environment, interruptible: interruptible, redirectStderr: redirectStderr)
 }
 
 package func runHostProcess(_ args: [String], workingDirectory: String? = nil, interruptible: Bool = true, redirectStderr: Bool = true) async throws -> String {
-    let processInfo = ProcessInfo.processInfo
-    switch try processInfo.hostOperatingSystem() {
+    switch try ProcessInfo.processInfo.hostOperatingSystem() {
     case .macOS:
         return try await InstalledXcode.currentlySelected().xcrun(args, workingDirectory: workingDirectory, redirectStderr: redirectStderr)
     default:
-        return try await runProcess(args, workingDirectory: workingDirectory, environment: processInfo.environment, interruptible: interruptible, redirectStderr: redirectStderr)
+        return try await runProcess(args, workingDirectory: workingDirectory, environment: .current, interruptible: interruptible, redirectStderr: redirectStderr)
     }
 }
 

Sources/SWBTestSupport/SkippedTestSupport.swift

@@ -215,13 +215,13 @@ extension Trait where Self == Testing.ConditionTrait {
         }
     }
 
-    package static func skipIfEnvironment(key: String, value: String) -> Self {
+    package static func skipIfEnvironment(key: EnvironmentKey, value: String) -> Self {
         disabled("environment sets '\(key)' to '\(value)'") {
             getEnvironmentVariable(key) == value
         }
     }
 
-    package static func skipIfEnvironmentVariableSet(key: String) -> Self {
+    package static func skipIfEnvironmentVariableSet(key: EnvironmentKey) -> Self {
         disabled("environment sets '\(key)'") {
             getEnvironmentVariable(key) != nil
         }

Sources/SWBUtil/Environment.swift

@@ -76,22 +76,9 @@ extension Environment {
 // MARK: - Global Environment
 
 extension Environment {
-    fileprivate static let _cachedCurrent = SWBMutex<Self?>(nil)
-
     /// Vends a copy of the current process's environment variables.
-    ///
-    /// Mutations to the current process's global environment are not reflected
-    /// in the returned value.
     public static var current: Self {
-        Self._cachedCurrent.withLock { cachedValue in
-            if let cachedValue = cachedValue {
-                return cachedValue
-            } else {
-                let current = Self(ProcessInfo.processInfo.environment)
-                cachedValue = current
-                return current
-            }
-        }
+        Self(ProcessInfo.processInfo.cleanEnvironment)
     }
 }
 
@@ -162,3 +149,34 @@ extension Environment: Decodable {
 }
 
 extension Environment: Sendable {}
+
+extension Environment {
+    public func filter(_ isIncluded: @escaping (Dictionary<EnvironmentKey, String>.Element) throws -> Bool) rethrows -> Environment {
+        try Environment(storage: storage.filter(isIncluded))
+    }
+
+    public func filter<KeyCollection: Collection>(keys: KeyCollection) -> Environment where KeyCollection.Element == EnvironmentKey {
+        return filter { key, _ in keys.contains(key) }
+    }
+
+    public mutating func addContents(of other: Environment) {
+        storage.addContents(of: other.storage)
+    }
+
+    public func addingContents(of other: Environment) -> Environment {
+        var env = self
+        env.addContents(of: other)
+        return env
+    }
+
+    public mutating func addContents(of other: [EnvironmentKey: String]) {
+        storage.addContents(of: other)
+    }
+
+    public func addingContents(of other: [EnvironmentKey: String]) -> Environment {
+        var env = self
+        env.addContents(of: other)
+        return env
+    }
+
+}

Sources/SWBUtil/EnvironmentHelpers.swift

@@ -12,25 +12,25 @@
 
 import Foundation
 
-@TaskLocal fileprivate var processEnvironment = ProcessInfo.processInfo.environment
+@TaskLocal fileprivate var processEnvironment = Environment.current
 
 /// Binds the internal defaults to the specified `environment` for the duration of the synchronous `operation`.
 /// - parameter clean: `true` to start with a clean environment, `false` to merge the input environment over the existing process environment.
 /// - note: This is implemented via task-local values.
-@_spi(Testing) public func withEnvironment<R>(_ environment: [String: String], clean: Bool = false, operation: () throws -> R) rethrows -> R {
+@_spi(Testing) public func withEnvironment<R>(_ environment: Environment, clean: Bool = false, operation: () throws -> R) rethrows -> R {
     try $processEnvironment.withValue(clean ? environment : processEnvironment.addingContents(of: environment), operation: operation)
 }
 
 /// Binds the internal defaults to the specified `environment` for the duration of the asynchronous `operation`.
 /// - parameter clean: `true` to start with a clean environment, `false` to merge the input environment over the existing process environment.
 /// - note: This is implemented via task-local values.
-@_spi(Testing) public func withEnvironment<R>(_ environment: [String: String], clean: Bool = false, operation: () async throws -> R) async rethrows -> R {
+@_spi(Testing) public func withEnvironment<R>(_ environment: Environment, clean: Bool = false, operation: () async throws -> R) async rethrows -> R {
     try await $processEnvironment.withValue(clean ? environment : processEnvironment.addingContents(of: environment), operation: operation)
 }
 
 /// Gets the value of the named variable from the process' environment.
 /// - parameter name: The name of the environment variable.
 /// - returns: The value of the variable as a `String`, or `nil` if it is not defined in the environment.
-public func getEnvironmentVariable(_ name: String) -> String? {
+public func getEnvironmentVariable(_ name: EnvironmentKey) -> String? {
     processEnvironment[name]
 }

Sources/SWBUtil/EnvironmentKey.swift

@@ -25,6 +25,10 @@ extension EnvironmentKey {
     package static let path: Self = "PATH"
 }
 
+extension EnvironmentKey {
+    package static let developerDir: Self = "DEVELOPER_DIR"
+}
+
 extension EnvironmentKey: CodingKeyRepresentable {}
 
 extension EnvironmentKey: Comparable {

Sources/SWBUtil/PbxCp.swift

@@ -80,7 +80,7 @@ fileprivate func xSecCodePathIsSigned(_ path: Path) throws -> Bool {
 
 // FIXME: Move this fully to Swift Concurrency and execute the process via llbuild after PbxCp is fully converted to Swift
 /// Spawns a process and waits for it to finish, closing stdin and redirecting stdout and stderr to fdout. Failure to launch, non-zero exit code, or exit with a signal will throw an error.
-fileprivate func spawnTaskAndWait(_ launchPath: Path, _ arguments: [String]?, _ environment: [String: String]?, _ workingDirPath: String?, _ dryRun: Bool, _ stream: OutputByteStream) async throws {
+fileprivate func spawnTaskAndWait(_ launchPath: Path, _ arguments: [String]?, _ environment: Environment?, _ workingDirPath: String?, _ dryRun: Bool, _ stream: OutputByteStream) async throws {
     stream <<< launchPath.str
     for arg in arguments ?? [] {
         stream <<< " \(arg)"
@@ -97,7 +97,7 @@ fileprivate func spawnTaskAndWait(_ launchPath: Path, _ arguments: [String]?, _
     stream <<< "\(String(decoding: output, as: UTF8.self))"
 
     if !exitStatus.isSuccess {
-        throw RunProcessNonZeroExitError(args: [launchPath.str] + (arguments ?? []), workingDirectory: workingDirPath, environment: environment ?? [:], status: exitStatus, mergedOutput: ByteString(output))
+        throw RunProcessNonZeroExitError(args: [launchPath.str] + (arguments ?? []), workingDirectory: workingDirPath, environment: environment ?? .init(), status: exitStatus, mergedOutput: ByteString(output))
     }
 }