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
                     }