Reproduce the issue with SWIFTPM_CUSTOM_BIN_DIR

Author: MaxDesiatov

Sources/CoreCommands/SwiftCommandState.swift

@@ -302,7 +302,8 @@ package final class SwiftCommandState {
         self.logLevel = options.logging.logLevel
         self.observabilityHandler = SwiftCommandObservabilityHandler(outputStream: outputStream, logLevel: self.logLevel)
         let observabilitySystem = ObservabilitySystem(self.observabilityHandler)
-        self.observabilityScope = observabilitySystem.topScope
+        let observabilityScope = observabilitySystem.topScope
+        self.observabilityScope = observabilityScope
         self.shouldDisableSandbox = options.security.shouldDisableSandbox
         self.toolWorkspaceConfiguration = toolWorkspaceConfiguration
         self.workspaceDelegateProvider = workspaceDelegateProvider
@@ -355,6 +356,10 @@ package final class SwiftCommandState {
             explicitDirectory: options.locations.swiftSDKsDirectory
         )
 
+        self._hostToolchain = Result(catching: {
+            try UserToolchain(swiftSDK: SwiftSDK.hostSwiftSDK(fileSystem: fileSystem))
+        })
+
         // set global process logging handler
         Process.loggingHandler = { self.observabilityScope.emit(debug: $0) }
     }
@@ -847,17 +852,7 @@ package final class SwiftCommandState {
     }()
 
     /// Lazily compute the host toolchain used to compile the package description.
-    private lazy var _hostToolchain: Result<UserToolchain, Swift.Error> = {
-        return Result(catching: {
-            try UserToolchain(
-                swiftSDK: SwiftSDK.hostSwiftSDK(
-                    originalWorkingDirectory: self.originalWorkingDirectory,
-                    observabilityScope: self.observabilityScope
-                ),
-                fileSystem: self.fileSystem
-            )
-        })
-    }()
+    private let _hostToolchain: Result<UserToolchain, Swift.Error>
 
     private lazy var _manifestLoader: Result<ManifestLoader, Swift.Error> = {
         return Result(catching: {

Sources/PackageModel/SwiftSDKs/SwiftSDK.swift

@@ -480,14 +480,10 @@ public struct SwiftSDK: Equatable {
     }
 
     /// Returns the bin directory for the host.
-    ///
-    /// - Parameter originalWorkingDirectory: The working directory when the program was launched.
     private static func hostBinDir(
-        fileSystem: FileSystem,
-        originalWorkingDirectory: AbsolutePath? = nil
+        fileSystem: FileSystem
     ) throws -> AbsolutePath {
-        let originalWorkingDirectory = originalWorkingDirectory ?? fileSystem.currentWorkingDirectory
-        guard let cwd = originalWorkingDirectory else {
+        guard let cwd = fileSystem.currentWorkingDirectory else {
             return try AbsolutePath(validating: CommandLine.arguments[0]).parentDirectory
         }
         return try AbsolutePath(validating: CommandLine.arguments[0], relativeTo: cwd).parentDirectory
@@ -500,27 +496,23 @@ public struct SwiftSDK: Equatable {
         originalWorkingDirectory: AbsolutePath? = nil,
         environment: [String: String] = ProcessEnv.vars
     ) throws -> SwiftSDK {
-        try self.hostSwiftSDK(binDir, originalWorkingDirectory: originalWorkingDirectory, environment: environment)
+        try self.hostSwiftSDK(binDir, environment: environment)
     }
 
     /// The Swift SDK for the host platform.
     public static func hostSwiftSDK(
         _ binDir: AbsolutePath? = nil,
-        originalWorkingDirectory: AbsolutePath? = nil,
         environment: [String: String] = ProcessEnv.vars,
-        observabilityScope: ObservabilityScope? = nil
+        observabilityScope: ObservabilityScope? = nil,
+        fileSystem: any FileSystem = localFileSystem
     ) throws -> SwiftSDK {
-        let originalWorkingDirectory = originalWorkingDirectory ?? localFileSystem.currentWorkingDirectory
         // Select the correct binDir.
         if ProcessEnv.block["SWIFTPM_CUSTOM_BINDIR"] != nil {
             print("SWIFTPM_CUSTOM_BINDIR was deprecated in favor of SWIFTPM_CUSTOM_BIN_DIR")
         }
         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,
-            originalWorkingDirectory: originalWorkingDirectory
-        )
+        let binDir = try customBinDir ?? binDir ?? SwiftSDK.hostBinDir(fileSystem: fileSystem)
 
         let sdkPath: AbsolutePath?
         #if os(macOS)

Sources/swift-bootstrap/main.swift

@@ -222,13 +222,9 @@ struct SwiftBootstrapBuildTool: ParsableCommand {
         ]
 
         init(fileSystem: FileSystem, observabilityScope: ObservabilityScope, logLevel: Basics.Diagnostic.Severity) throws {
-            guard let cwd: AbsolutePath = fileSystem.currentWorkingDirectory else {
-                throw ExitCode.failure
-            }
-
             self.identityResolver = DefaultIdentityResolver()
             self.dependencyMapper = DefaultDependencyMapper(identityResolver: self.identityResolver)
-            self.hostToolchain = try UserToolchain(swiftSDK: SwiftSDK.hostSwiftSDK(originalWorkingDirectory: cwd))
+            self.hostToolchain = try UserToolchain(swiftSDK: SwiftSDK.hostSwiftSDK(fileSystem: fileSystem))
             self.targetToolchain = hostToolchain // TODO: support cross-compilation?
             self.fileSystem = fileSystem
             self.observabilityScope = observabilityScope

Tests/CommandsTests/SwiftCommandStateTests.swift

@@ -21,6 +21,7 @@ import CoreCommands
 import SPMTestSupport
 import XCTest
 
+import enum TSCBasic.ProcessEnv
 import class TSCBasic.BufferedOutputByteStream
 import protocol TSCBasic.OutputByteStream
 import var TSCBasic.stderrStream
@@ -319,19 +320,25 @@ final class SwiftCommandStateTests: CommandsTestCase {
     }
 
     func testToolchainArgument() throws {
+        let hostBinDir = AbsolutePath("/swiftpm/bin")
+        let hostSwiftcPath = hostBinDir.appending(components: ["swiftc"])
+
+        let customTargetToolchain = AbsolutePath("/path/to/toolchain")
+        let targetSwiftcPath = customTargetToolchain.appending(components: ["usr", "bin" , "swiftc"])
+        let targetArPath = customTargetToolchain.appending(components: ["usr", "bin", "llvm-ar"])
+
         let fs = InMemoryFileSystem(emptyFiles: [
             "/Pkg/Sources/exe/main.swift",
-            "/path/to/toolchain/usr/bin/swiftc",
-            "/path/to/toolchain/usr/bin/llvm-ar",
+            hostSwiftcPath.pathString,
+            targetSwiftcPath.pathString,
+            targetArPath.pathString
         ])
 
-        let customTargetToolchain = AbsolutePath("/path/to/toolchain")
-        try fs.createDirectory(customTargetToolchain, recursive: true)
-        
-        let swiftcPath = customTargetToolchain.appending(components: ["usr", "bin" , "swiftc"])
-        let arPath = customTargetToolchain.appending(components: ["usr", "bin", "llvm-ar"])
-        try fs.updatePermissions(swiftcPath, isExecutable: true)
-        try fs.updatePermissions(arPath, isExecutable: true)
+        try ProcessEnv.setVar("SWIFTPM_CUSTOM_BIN_DIR", value: hostBinDir.pathString)
+
+        try fs.updatePermissions(hostSwiftcPath, isExecutable: true)
+        try fs.updatePermissions(targetSwiftcPath, isExecutable: true)
+        try fs.updatePermissions(targetArPath, isExecutable: true)
 
         let observer = ObservabilitySystem.makeForTesting()
         let graph = try loadModulesGraph(
@@ -353,9 +360,10 @@ final class SwiftCommandStateTests: CommandsTestCase {
             ]
         )
         let swiftCommandState = try SwiftCommandState.makeMockState(options: options, fileSystem: fs)
+        XCTAssertEqual(swiftCommandState.originalWorkingDirectory, fs.currentWorkingDirectory)
         XCTAssertEqual(
             try swiftCommandState.getTargetToolchain().swiftCompilerPath,
-            swiftcPath
+            targetSwiftcPath
         )
         XCTAssertEqual(
             try swiftCommandState.getTargetToolchain().swiftSDK.toolset.knownTools[.swiftCompiler]?.path,