use newer environment type

Author: rauhul

CONTRIBUTORS.txt

@@ -291,7 +291,7 @@ needs to be listed here.
 - Quinn McHenry <quinn@jqm.us>
 - Rahul Malik <rmalik@pinterest.com>
 - Randy Becker <81446220+randy-becker@users.noreply.github.com>
-- Rauhul Varma <rauhul@users.noreply.github.com>
+- Rauhul Varma <rauhul@apple.com>
 - Renzo Crisóstomo <renzo.crisostomo@xing.com>
 - Rich Ellis <rich@richellis.net>
 - Rick Ballard <rballard@apple.com>

Package.swift

@@ -184,9 +184,12 @@ let package = Package(
 
         .systemLibrary(name: "SPMSQLite3", pkgConfig: systemSQLitePkgConfig),
 
+        .target(name: "Environment"),
+
         .target(
             name: "Basics",
             dependencies: [
+                "Environment",
                 "SPMSQLite3",
                 .product(name: "DequeModule", package: "swift-collections"),
                 .product(name: "OrderedCollections", package: "swift-collections"),
@@ -622,6 +625,10 @@ let package = Package(
             ]
         ),
 
+        .testTarget(
+            name: "EnvironmentTests",
+            dependencies: ["Environment"]),
+
         .testTarget(
             name: "BasicsTests",
             dependencies: ["Basics", "SPMTestSupport", "tsan_utils"],

Sources/Basics/Archiver/TarArchiver.swift

@@ -93,6 +93,7 @@ public struct TarArchiver: Archiver {
 
             let process = TSCBasic.Process(
                 arguments: [self.tarCommand, "acf", destinationPath.pathString, directory.basename],
+                environment: .current,
                 workingDirectory: directory.parentDirectory.underlying
             )
 

Sources/Basics/CMakeLists.txt

@@ -25,7 +25,7 @@ add_library(Basics
   Concurrency/ThreadSafeKeyValueStore.swift
   Concurrency/TokenBucket.swift
   DispatchTimeInterval+Extensions.swift
-  EnvironmentVariables.swift
+  Environment.swift
   Errors.swift
   FileSystem/AbsolutePath.swift
   FileSystem/FileSystem+Extensions.swift

Sources/Basics/Concurrency/ConcurrencyHelpers.swift

@@ -15,12 +15,11 @@ import Dispatch
 import class Foundation.NSLock
 import class Foundation.ProcessInfo
 import struct Foundation.URL
-import enum TSCBasic.ProcessEnv
 import func TSCBasic.tsc_await
 
 public enum Concurrency {
     public static var maxOperations: Int {
-        ProcessEnv.block["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
+        Environment.current["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
             .activeProcessorCount
     }
 }

Sources/Basics/EnvironmentVariables.swift

@@ -10,99 +10,149 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
-import class Foundation.ProcessInfo
+@_exported import Environment
 import struct TSCBasic.ProcessEnvironmentBlock
-import struct TSCBasic.ProcessEnvironmentKey
-import enum TSCBasic.ProcessEnv
 
-public typealias ProcessEnvironmentBlock = TSCBasic.ProcessEnvironmentBlock
+import class TSCBasic.Process
+import struct TSCBasic.ProcessResult
+import struct TSCBasic.AbsolutePath
 
-extension ProcessEnvironmentBlock {
-    public static var current: ProcessEnvironmentBlock { ProcessEnv.block }
+import Dispatch
 
-    public mutating func prependPath(value: String) {
-        if let existing = self[Self.pathKey] {
-            self[Self.pathKey] = "\(value):\(existing)"
-        } else {
-            self[Self.pathKey] = value
+// FIXME: remove ProcessEnvironmentBlockShims
+// only needed outside this module for Git
+extension Environment {
+    @_spi(ProcessEnvironmentBlockShim)
+    public init(_ processEnvironmentBlock: ProcessEnvironmentBlock) {
+        self.init()
+        for (key, value) in processEnvironmentBlock {
+            self[.init(key.value)] = value
+        }
+    }
+}
+
+extension ProcessEnvironmentBlock {
+    @_spi(ProcessEnvironmentBlockShim)
+    public init(_ environment: Environment) {
+        self.init()
+        for (key, value) in environment {
+            self[.init(key.rawValue)] = value
         }
     }
+}
 
-    public mutating func appendPath(value: String) {
-        if let existing = self[Self.pathKey] {
-            self[Self.pathKey] = "\(existing):\(value)"
+// MARK: - Process Shims
+extension TSCBasic.Process {
+    package convenience init(
+        arguments: [String],
+        environment: Environment = .current,
+        workingDirectory: TSCBasic.AbsolutePath? = nil,
+        outputRedirection: OutputRedirection = .collect,
+        startNewProcessGroup: Bool = true,
+        loggingHandler: LoggingHandler? = .none
+    ) {
+        if let workingDirectory {
+            self.init(arguments: arguments, environmentBlock: .init(environment), workingDirectory: workingDirectory, outputRedirection: outputRedirection, startNewProcessGroup: startNewProcessGroup, loggingHandler: loggingHandler)
         } else {
-            self[Self.pathKey] = value
+            self.init(arguments: arguments, environmentBlock: .init(environment), outputRedirection: outputRedirection, startNewProcessGroup: startNewProcessGroup, loggingHandler: loggingHandler)
         }
     }
+}
 
-    /// `PATH` variable in the process's environment (`Path` under Windows).
-    package var path: String? { self[Self.pathKey] }
+extension TSCBasic.Process {
+    static package func popen(
+        arguments: [String],
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil,
+        queue: DispatchQueue? = nil,
+        completion: @escaping (Result<ProcessResult, Swift.Error>) -> Void
+    ) {
+        popen(arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler,queue: queue,completion: completion)
+    }
 
-    package static var pathValueDelimiter: String {
-        #if os(Windows)
-        ";"
-        #else
-        ":"
-        #endif
+    @discardableResult
+    static package func popen(
+        arguments: [String],
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) throws -> ProcessResult {
+        try popen(arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler)
     }
 
-    package static var pathKey: ProcessEnvironmentKey {
-        #if os(Windows)
-        "Path"
-        #else
-        "PATH"
-        #endif
+    @discardableResult
+    static package func popen(
+        args: String...,
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) throws -> ProcessResult {
+        try popen(arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler)
     }
-}
 
-// filter env variable that should not be included in a cache as they change
-// often and should not be considered in business logic
-// rdar://107029374
-extension ProcessEnvironmentBlock {
-    // internal for testing
-    static let nonCachableKeys: Set<ProcessEnvironmentKey> = [
-        "TERM",
-        "TERM_PROGRAM",
-        "TERM_PROGRAM_VERSION",
-        "TERM_SESSION_ID",
-        "ITERM_PROFILE",
-        "ITERM_SESSION_ID",
-        "SECURITYSESSIONID",
-        "LaunchInstanceID",
-        "LC_TERMINAL",
-        "LC_TERMINAL_VERSION",
-        "CLICOLOR",
-        "LS_COLORS",
-        "VSCODE_IPC_HOOK_CLI",
-        "HYPERFINE_RANDOMIZED_ENVIRONMENT_OFFSET",
-        "SSH_AUTH_SOCK",
-    ]
-
-    /// Returns a copy of `self` with known non-cacheable keys removed.
-    public var cachable: ProcessEnvironmentBlock {
-        self.filter { !Self.nonCachableKeys.contains($0.key) }
+    static package func popen(
+        arguments: [String],
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) async throws -> ProcessResult {
+        try await popen(arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler)
+    }
+
+    static package func popen(
+        args: String...,
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) async throws -> ProcessResult {
+        try await popen(arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler)
     }
 }
 
-extension ProcessEnvironmentKey: @retroactive Comparable {
-    public static func < (lhs: Self, rhs: Self) -> Bool {
-        #if os(Windows)
-        // TODO: is this any faster than just doing a lowercased conversion and compare?
-        lhs.value.caseInsensitiveCompare(rhs.value) == .orderedAscending
-        #else
-        lhs.value < rhs.value
-        #endif
+extension TSCBasic.Process {
+    @discardableResult
+    static package func checkNonZeroExit(
+        arguments: [String],
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) throws -> String {
+        try checkNonZeroExit(arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler)
+    }
+
+    @discardableResult
+    static package func checkNonZeroExit(
+        arguments: [String],
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) async throws -> String {
+        try await checkNonZeroExit(arguments: arguments, environmentBlock: .init(environment), loggingHandler: loggingHandler)
+    }
+
+    @discardableResult
+    static package func checkNonZeroExit(
+        args: String...,
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) throws -> String {
+        try checkNonZeroExit(arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler)
+    }
+
+
+    @discardableResult
+    static package func checkNonZeroExit(
+        args: String...,
+        environment: Environment,
+        loggingHandler: LoggingHandler? = nil
+    ) async throws -> String {
+        try await checkNonZeroExit(arguments: args, environmentBlock: .init(environment), loggingHandler: loggingHandler)
     }
 }
 
-extension ProcessEnvironmentBlock {
-    package func nonPortable() -> [String: String] {
-        var dict = [String: String]()
-        for (key, value) in self {
-            dict[key.value] = value
-        }
-        return dict
+// MARK: ProcessResult Shims
+extension ProcessResult {
+    package init(
+        arguments: [String],
+        environment: Environment,
+        exitStatus: ExitStatus,
+        output: Result<[UInt8], Swift.Error>,
+        stderrOutput: Result<[UInt8], Swift.Error>
+    ) {
+        self.init(arguments: arguments, environmentBlock: .init(environment), exitStatus: exitStatus, output: output, stderrOutput: stderrOutput)
     }
 }

Sources/Basics/FileSystem/FileSystem+Extensions.swift

@@ -23,7 +23,6 @@ import protocol TSCBasic.FileSystem
 import enum TSCBasic.FileSystemAttribute
 import var TSCBasic.localFileSystem
 import protocol TSCBasic.WritableByteStream
-import enum TSCBasic.ProcessEnv
 
 public typealias FileSystem = TSCBasic.FileSystem
 public let localFileSystem = TSCBasic.localFileSystem
@@ -215,7 +214,7 @@ extension FileSystem {
     /// or under $XDG_CONFIG_HOME/swiftpm if the environmental variable is defined
     public var dotSwiftPM: AbsolutePath {
         get throws {
-            if let configurationDirectory = ProcessEnv.block["XDG_CONFIG_HOME"] {
+            if let configurationDirectory = Environment.current["XDG_CONFIG_HOME"] {
                 return try AbsolutePath(validating: configurationDirectory).appending("swiftpm")
             } else {
                 return try self.homeDirectory.appending(".swiftpm")

Sources/Basics/ImportScanning.swift

@@ -14,7 +14,6 @@ import Dispatch
 
 import class Foundation.JSONDecoder
 import class TSCBasic.Process
-import struct TSCBasic.ProcessEnvironmentBlock
 
 private let defaultImports = ["Swift", "SwiftOnoneSupport", "_Concurrency",
                               "_StringProcessing", "_SwiftConcurrencyShims"]
@@ -23,17 +22,17 @@ private struct Imports: Decodable {
     let imports: [String]
 }
 
-public protocol ImportScanner {
+package protocol ImportScanner {
     func scanImports(_ filePathToScan: AbsolutePath) async throws -> [String]
 }
 
 public struct SwiftcImportScanner: ImportScanner {
-    private let swiftCompilerEnvironment: ProcessEnvironmentBlock
+    private let swiftCompilerEnvironment: Environment
     private let swiftCompilerFlags: [String]
     private let swiftCompilerPath: AbsolutePath
 
-    public init(
-        swiftCompilerEnvironment: ProcessEnvironmentBlock,
+    package init(
+        swiftCompilerEnvironment: Environment,
         swiftCompilerFlags: [String],
         swiftCompilerPath: AbsolutePath
     ) {
@@ -47,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, environmentBlock: self.swiftCompilerEnvironment)
+        let result = try await TSCBasic.Process.popen(arguments: cmd, environment: self.swiftCompilerEnvironment)
 
         let stdout = try result.utf8Output()
         return try JSONDecoder.makeWithDefaults().decode(Imports.self, from: stdout).imports

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -20,8 +20,6 @@ import struct SPMBuildCore.BuildParameters
 import struct SPMBuildCore.BuildToolPluginInvocationResult
 import struct SPMBuildCore.PrebuildCommandResult
 
-import enum TSCBasic.ProcessEnv
-
 /// Target description for a Clang target i.e. C language family target.
 public final class ClangTargetBuildDescription {
     /// The package this target belongs to.

Sources/Build/BuildManifest/LLBuildManifestBuilder+Swift.swift

@@ -19,9 +19,8 @@ import struct LLBuildManifest.LLBuildManifest
 import struct SPMBuildCore.BuildParameters
 import struct PackageGraph.ResolvedModule
 import protocol TSCBasic.FileSystem
-import enum TSCBasic.ProcessEnv
 import func TSCBasic.topologicalSort
-import struct Basics.ProcessEnvironmentBlock
+import struct Basics.Environment
 
 #if USE_IMPL_ONLY_IMPORTS
 @_implementationOnly import class DriverSupport.SPMSwiftDriverExecutor
@@ -76,7 +75,7 @@ extension LLBuildManifestBuilder {
         let executor = SPMSwiftDriverExecutor(
             resolver: resolver,
             fileSystem: target.fileSystem,
-            env: ProcessEnvironmentBlock.current
+            env: Environment.current
         )
         var driver = try Driver(
             args: commandLine,
@@ -291,7 +290,7 @@ extension LLBuildManifestBuilder {
         let executor = SPMSwiftDriverExecutor(
             resolver: resolver,
             fileSystem: self.fileSystem,
-            env: ProcessEnvironmentBlock.current
+            env: Environment.current
         )
         var driver = try Driver(
             args: commandLine,

Sources/Build/BuildManifest/LLBuildManifestBuilder.swift

@@ -23,7 +23,6 @@ import SwiftDriver
 #endif
 
 import struct TSCBasic.ByteString
-import enum TSCBasic.ProcessEnv
 import func TSCBasic.topologicalSort
 
 /// High-level interface to ``LLBuildManifest`` and ``LLBuildManifestWriter``.