Get search paths only in determineSwiftCompilers

Author: MaxDesiatov

Sources/Commands/SwiftTool.swift

@@ -639,10 +639,6 @@ public class SwiftTool {
         } catch {
             return .failure(error)
         }
-        // Get the search paths from PATH.
-        let searchPaths = getEnvSearchPaths(
-            pathString: ProcessEnv.vars["PATH"], currentWorkingDirectory: localFileSystem.currentWorkingDirectory)
-
         // Apply any manual overrides.
         if let triple = self.options.customCompileTriple {
             destination.target = triple
@@ -656,7 +652,7 @@ public class SwiftTool {
             // Set default SDK path when target is WASI whose SDK is embeded
             // in Swift toolchain
             do {
-                let compilers = try UserToolchain.determineSwiftCompilers(binDir: destination.binDir, envSearchPaths: searchPaths)
+                let compilers = try UserToolchain.determineSwiftCompilers(binDir: destination.binDir)
                 destination.sdk = compilers.compile
                     .parentDirectory // bin
                     .parentDirectory // usr
@@ -672,17 +668,13 @@ public class SwiftTool {
             return self._hostToolchain
         }
 
-        return Result(catching: { try UserToolchain(destination: destination, searchPaths: searchPaths) })
+        return Result(catching: { try UserToolchain(destination: destination) })
     }()
 
     /// Lazily compute the host toolchain used to compile the package description.
     private lazy var _hostToolchain: Result<UserToolchain, Swift.Error> = {
-        // Get the search paths from PATH.
-        let searchPaths = getEnvSearchPaths(
-            pathString: ProcessEnv.vars["PATH"], currentWorkingDirectory: localFileSystem.currentWorkingDirectory)
-        return Result(catching: {
-            try UserToolchain(destination: Destination.hostDestination(
-                        originalWorkingDirectory: self.originalWorkingDirectory), searchPaths: searchPaths)
+        Result(catching: {
+            try UserToolchain(destination: .hostDestination(originalWorkingDirectory: self.originalWorkingDirectory))
         })
     }()
 

Sources/SPMTestSupport/Resources.swift

@@ -59,9 +59,7 @@ public class Resources: ManifestResourceProvider {
       #else
         binDir = AbsolutePath(CommandLine.arguments[0], relativeTo: localFileSystem.currentWorkingDirectory!).parentDirectory
       #endif
-        let searchPaths = getEnvSearchPaths(
-            pathString: ProcessEnv.vars["PATH"], currentWorkingDirectory: localFileSystem.currentWorkingDirectory)
-        toolchain = try! UserToolchain(destination: Destination.hostDestination(binDir), searchPaths: searchPaths)
+        toolchain = try! UserToolchain(destination: Destination.hostDestination(binDir))
     }
 
     /// True if SwiftPM has PackageDescription 4 runtime available.

Sources/Workspace/UserToolchain.swift

@@ -57,9 +57,6 @@ public final class UserToolchain: Toolchain {
     /// The list of archs to build for.
     public let archs: [String]
 
-    /// Search paths from the PATH environment variable.
-    let envSearchPaths: [AbsolutePath]
-
     /// Returns the runtime library for the given sanitizer.
     public func runtimeLibrary(for sanitizer: Sanitizer) throws -> AbsolutePath {
         // FIXME: This is only for SwiftPM development time support. It is OK
@@ -105,14 +102,20 @@ public final class UserToolchain: Toolchain {
     public typealias SwiftCompilers = (compile: AbsolutePath, manifest: AbsolutePath)
 
     /// Determines the Swift compiler paths for compilation and manifest parsing.
-    public static func determineSwiftCompilers(binDir: AbsolutePath, envSearchPaths: [AbsolutePath]) throws -> SwiftCompilers {
+    public static func determineSwiftCompilers(binDir: AbsolutePath) throws -> SwiftCompilers {
         func validateCompiler(at path: AbsolutePath?) throws {
             guard let path = path else { return }
             guard localFileSystem.isExecutableFile(path) else {
                 throw InvalidToolchainDiagnostic("could not find the `swiftc\(hostExecutableSuffix)` at expected path \(path)")
             }
         }
 
+        // Get the search paths from PATH.
+        let searchPaths = getEnvSearchPaths(
+            pathString: ProcessEnv.path,
+            currentWorkingDirectory: localFileSystem.currentWorkingDirectory
+        )
+
         let lookup = { UserToolchain.lookup(variable: $0, searchPaths: envSearchPaths) }
         // Get overrides.
         let SWIFT_EXEC_MANIFEST = lookup("SWIFT_EXEC_MANIFEST")
@@ -144,9 +147,6 @@ public final class UserToolchain: Toolchain {
         return lookupExecutablePath(filename: ProcessEnv.vars[variable], searchPaths: searchPaths)
     }
 
-    /// Environment to use when looking up tools.
-    private let processEnvironment: [String: String]
-
     /// Returns the path to clang compiler tool.
     public func getClangCompiler() throws -> AbsolutePath {
         // Check if we already computed.
@@ -267,25 +267,16 @@ public final class UserToolchain: Toolchain {
             + destination.extraSwiftCFlags
     }
 
-    public init(destination: Destination, searchPaths: [AbsolutePath], environment: [String: String] = ProcessEnv.vars) throws {
+    public init(destination: Destination) throws {
         self.destination = destination
-        self.processEnvironment = environment
-
-        // Get the search paths from PATH.
-        let searchPaths = getEnvSearchPaths(
-            pathString: ProcessEnv.path, 
-            currentWorkingDirectory: localFileSystem.currentWorkingDirectory
-        ) + searchPaths
-
-        self.envSearchPaths = searchPaths
 
         // Get the binDir from destination.
         let binDir = destination.binDir
 
-        let swiftCompilers = try UserToolchain.determineSwiftCompilers(binDir: binDir, envSearchPaths: searchPaths)
+        let swiftCompilers = try UserToolchain.determineSwiftCompilers(binDir: binDir)
         self.swiftCompiler = swiftCompilers.compile
         self.archs = destination.archs
-    
+
         // Use the triple from destination or compute the host triple using swiftc.
         var triple = destination.target ?? Triple.getHostTriple(usingSwiftCompiler: swiftCompilers.compile)