ADD - look for tools relative to the executable path.

Once swift-driver is installed in the Toolchain, we can look for tools right next to it's executable path, this help us to be more platform agnostic while locating the toolchain.

This is the first step in this direction, we will need to make this more robust to get rid of xcrun if possible, and get a proper linux implementation.

Author: JhonnyBillM

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -20,38 +20,25 @@ fileprivate func envVarName(forExecutable toolName: String) -> String {
 /// FIXME: This class is not thread-safe.
 public final class DarwinToolchain: Toolchain {
   public let env: [String: String]
-
-  func xcrunFind(exec: String) throws -> AbsolutePath {
-    if let overrideString = env[envVarName(forExecutable: exec)] {
-      return try AbsolutePath(validating: overrideString)
-    }
-
-  #if os(macOS)
-    let path = try Process.checkNonZeroExit(
-      arguments: ["xcrun", "-sdk", "macosx", "--find", exec],
-      environment: env
-    ).spm_chomp()
-    return AbsolutePath(path)
-  #else
-    // This is a hack so our tests work on linux. We need a better way for looking up tools in general.
-    return AbsolutePath("/usr/bin/" + exec)
-  #endif
+  
+  public init(env: [String: String]) {
+    self.env = env
   }
-
+  
   /// Retrieve the absolute path for a given tool.
   public func getToolPath(_ tool: Tool) throws -> AbsolutePath {
     switch tool {
     case .swiftCompiler:
-      return try xcrunFind(exec: "swift")
+      return try lookup(exec: "swift")
 
     case .dynamicLinker:
-      return try xcrunFind(exec: "ld")
+      return try lookup(exec: "ld")
 
     case .staticLinker:
-      return try xcrunFind(exec: "libtool")
+      return try lookup(exec: "libtool")
 
     case .dsymutil:
-      return try xcrunFind(exec: "dsymutil")
+      return try lookup(exec: "dsymutil")
 
     case .clang:
       let result = try Process.checkNonZeroExit(
@@ -60,13 +47,13 @@ public final class DarwinToolchain: Toolchain {
       ).spm_chomp()
       return AbsolutePath(result)
     case .swiftAutolinkExtract:
-      return try xcrunFind(exec: "swift-autolink-extract")
+      return try lookup(exec: "swift-autolink-extract")
     }
   }
 
   /// Swift compiler path.
   public lazy var swiftCompiler: Result<AbsolutePath, Swift.Error> = Result {
-    try xcrunFind(exec: "swift")
+    try lookup(exec: "swift")
   }
 
   /// SDK path.
@@ -88,11 +75,6 @@ public final class DarwinToolchain: Toolchain {
     return swiftCompiler.map{ $0.appending(RelativePath("../../lib/swift/macosx")) }
   }
 
-  
-  public init(env: [String: String]) {
-    self.env = env
-  }
-
   public func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String {
     switch type {
     case .executable: return moduleName
@@ -137,4 +119,29 @@ public final class DarwinToolchain: Toolchain {
     \(isShared ? "_dynamic.dylib" : ".a")
     """
   }
+  
+  /// Looks for the executable in the `SWIFT_DRIVER_TOOLNAME_EXEC` enviroment variable, if found nothing,
+  /// looks in the executable path; finally, fallback to xcrunFind.
+  /// - Parameter exec: executable to look for [i.e. `swift`].
+  func lookup(exec: String) throws -> AbsolutePath {
+    if let overrideString = env[envVarName(forExecutable: exec)] {
+      return try AbsolutePath(validating: overrideString)
+    } else if let path = lookupExecutablePath(filename: exec, searchPaths: [executableDir]) {
+      return path
+    }
+    return try xcrunFind(exec: exec)
+  }
+  
+  private func xcrunFind(exec: String) throws -> AbsolutePath {
+  #if os(macOS)
+    let path = try Process.checkNonZeroExit(
+      arguments: ["xcrun", "-sdk", "macosx", "--find", exec],
+      environment: env
+    ).spm_chomp()
+    return AbsolutePath(path)
+  #else
+    // This is a hack so our tests work on linux. We need a better way for looking up tools in general.
+    return AbsolutePath("/usr/bin/" + exec)
+  #endif
+  }
 }

Sources/SwiftDriver/Toolchains/GenericUnixToolchain.swift

@@ -26,19 +26,22 @@ public final class GenericUnixToolchain: Toolchain {
     self.searchPaths = getEnvSearchPaths(pathString: env["PATH"], currentWorkingDirectory: localFileSystem.currentWorkingDirectory)
   }
 
+  /// Looks in the `executablePath`, if found nothing, looks in the enviroment search paths.
+  /// - Parameter exec: executable to look for [i.e. `swift`].
   private func lookup(exec: String) throws -> AbsolutePath {
-    if let path = lookupExecutablePath(filename: exec, searchPaths: searchPaths) {
+    if let path = lookupExecutablePath(filename: exec, searchPaths: [executableDir]) {
+      return path
+    } else if let path = lookupExecutablePath(filename: exec, searchPaths: searchPaths) {
       return path
     }
 
     // If we happen to be on a macOS host, some tools might not be in our
     // PATH, so we'll just use xcrun to find them too.
     #if os(macOS)
-    return try DarwinToolchain(env: self.env).xcrunFind(exec: exec)
+    return try DarwinToolchain(env: self.env).lookup(exec: exec)
     #else
     throw Error.unableToFind(tool: exec)
     #endif
-
   }
 
   public func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String {

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -9,6 +9,7 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+import Foundation
 import TSCBasic
 
 public enum Tool {
@@ -74,4 +75,12 @@ extension Toolchain {
     ).spm_chomp()
     return Triple(triple)
   }
+  
+  /// Returns the `executablePath`'s directory.
+  public var executableDir: AbsolutePath {
+    guard let path = Bundle.main.executablePath else {
+      fatalError("Could not find executable path.")
+    }
+    return AbsolutePath(path).parentDirectory
+  }
 }