[DNM] Test Logging

Author: jmschonfeld

Sources/Basics/FileSystem/TSCAdapters.swift

@@ -108,7 +108,8 @@ public func getEnvSearchPaths(
     pathString: String?,
     currentWorkingDirectory: AbsolutePath?
 ) -> [AbsolutePath] {
-    TSCBasic.getEnvSearchPaths(
+    print("Getting env search paths for PATH=\(pathString), CWD=\(currentWorkingDirectory)")
+    return TSCBasic.getEnvSearchPaths(
         pathString: pathString,
         currentWorkingDirectory: currentWorkingDirectory?.underlying
     ).map { AbsolutePath($0) }

Sources/PackageModel/UserToolchain.swift

@@ -126,13 +126,16 @@ public final class UserToolchain: Toolchain {
         fileSystem: any FileSystem
     ) throws -> AbsolutePath {
         let executableName = "\(name)\(hostExecutableSuffix)"
+        print("getTool: \(executableName) in \(binDirectories)")
         var toolPath: AbsolutePath?
 
         for dir in binDirectories {
             let path = dir.appending(component: executableName)
             guard fileSystem.isExecutableFile(path) else {
+                print("Trying \(path)... not executable file")
                 continue
             }
+            print("Trying \(path)... SUCCESS")
             toolPath = path
             // Take the first match.
             break
@@ -230,19 +233,25 @@ public final class UserToolchain: Toolchain {
         searchPaths: [AbsolutePath],
         fileSystem: any FileSystem
     ) throws -> SwiftCompilers {
+        print("Determining swift compilers with binDirectories: \(binDirectories), searchPaths: \(searchPaths)")
         func validateCompiler(at path: AbsolutePath?) throws {
+            print("Validating compiler at \(path)")
             guard let path else { return }
             guard fileSystem.isExecutableFile(path) else {
                 throw InvalidToolchainDiagnostic(
                     "could not find the `swiftc\(hostExecutableSuffix)` at expected path \(path)"
                 )
             }
+            print("VALID")
         }
 
         let lookup = { UserToolchain.lookup(variable: $0, searchPaths: searchPaths, environment: environment) }
         // Get overrides.
         let SWIFT_EXEC_MANIFEST = lookup("SWIFT_EXEC_MANIFEST")
         let SWIFT_EXEC = lookup("SWIFT_EXEC")
+        
+        print("SWIFT_EXEC: \(SWIFT_EXEC)")
+        print("SWIFT_EXEC_MANIFEST: \(SWIFT_EXEC_MANIFEST)")
 
         // Validate the overrides.
         try validateCompiler(at: SWIFT_EXEC)
@@ -254,6 +263,7 @@ public final class UserToolchain: Toolchain {
         if let SWIFT_EXEC {
             resolvedBinDirCompiler = SWIFT_EXEC
         } else if let binDirCompiler = try? UserToolchain.getTool("swiftc", binDirectories: binDirectories, fileSystem: fileSystem) {
+            print("Resolved directly to \(binDirCompiler)")
             resolvedBinDirCompiler = binDirCompiler
         } else {
             // Try to lookup swift compiler on the system which is possible when
@@ -264,6 +274,7 @@ public final class UserToolchain: Toolchain {
                 useXcrun: useXcrun,
                 fileSystem: fileSystem
             )
+            print("Resolved eventually to \(resolvedBinDirCompiler)")
         }
 
         // The compiler for compilation tasks is SWIFT_EXEC or the bin dir compiler.
@@ -541,12 +552,14 @@ public final class UserToolchain: Toolchain {
                 pathString: environment[.path],
                 currentWorkingDirectory: fileSystem.currentWorkingDirectory
             )
+            print("Default search strategy envSearchPaths=\(envSearchPaths)")
             self.useXcrun = true
         case .custom(let searchPaths, let useXcrun):
             self.envSearchPaths = searchPaths
+            print("Custom search strategy envSearchPaths=\(envSearchPaths)")
             self.useXcrun = useXcrun
         }
-
+        print("Toolset known tools: \(swiftSDK.toolset.knownTools)")
         let swiftCompilers = try UserToolchain.determineSwiftCompilers(
             binDirectories: swiftSDK.toolset.rootPaths,
             useXcrun: self.useXcrun,