[Toolchains] Generalize lookup routines as a Toolchain extension.

Author: JhonnyBillM

Sources/SwiftDriver/Toolchains/DarwinToolchain.swift

@@ -115,29 +115,4 @@ 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 = envVar(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

@@ -13,35 +13,10 @@ import TSCBasic
 
 /// Toolchain for Unix-like systems.
 public final class GenericUnixToolchain: Toolchain {
-  enum Error: Swift.Error {
-    case unableToFind(tool: String)
-  }
-  
   public let env: [String: String]
 
-  private let searchPaths: [AbsolutePath]
-
   public init(env: [String: String]) {
     self.env = env
-    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: [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).lookup(exec: exec)
-    #else
-    throw Error.unableToFind(tool: exec)
-    #endif
   }
 
   public func makeLinkerOutputFilename(moduleName: String, type: LinkOutputType) -> String {

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -28,6 +28,8 @@ public protocol Toolchain {
 
   var env: [String: String] { get }
 
+  var searchPaths: [AbsolutePath] { get }
+  
   /// Retrieve the absolute path to a particular tool.
   func getToolPath(_ tool: Tool) throws -> AbsolutePath
 
@@ -60,6 +62,10 @@ public protocol Toolchain {
 }
 
 extension Toolchain {
+  public var searchPaths: [AbsolutePath] {
+    getEnvSearchPaths(pathString: env["PATH"], currentWorkingDirectory: localFileSystem.currentWorkingDirectory)
+  }
+  
   public func swiftCompilerVersion() throws -> String {
     try Process.checkNonZeroExit(
       args: getToolPath(.swiftCompiler).pathString, "-version",
@@ -94,4 +100,38 @@ extension Toolchain {
   private func envVarName(for toolName: String) -> String {
     return "SWIFT_DRIVER_\(toolName.uppercased())_EXEC"
   }
+  
+  /// Looks for the executable in the `SWIFT_DRIVER_TOOLNAME_EXEC` enviroment variable, if found nothing,
+  /// looks in the `executableDir`, `xcrunFind` or in the `searchPaths`.
+  /// - Parameter exec: executable to look for [i.e. `swift`].
+  func lookup(exec: String) throws -> AbsolutePath {
+    if let overrideString = envVar(forExecutable: exec) {
+      return try AbsolutePath(validating: overrideString)
+    } else if let path = lookupExecutablePath(filename: exec, searchPaths: [executableDir]) {
+      return path
+    } else if let path = try? xcrunFind(exec: exec) {
+      return path
+    } else if let path = lookupExecutablePath(filename: exec, searchPaths: searchPaths) {
+      return path
+    } else {
+      throw ToolchainError.unableToFind(tool: 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
+  }
+}
+
+fileprivate enum ToolchainError: Swift.Error {
+  case unableToFind(tool: String)
 }

Tests/SwiftDriverTests/JobExecutorTests.swift

@@ -191,15 +191,25 @@ final class JobExecutorTests: XCTestCase {
 
   func testSwiftDriverExecOverride() throws {
     var env = ProcessEnv.vars
+    let envVarName = "SWIFT_DRIVER_SWIFT_EXEC"
+    let dummyPath = "/some/garbage/path/fnord"
 
-    env.removeValue(forKey: "SWIFT_DRIVER_SWIFT_EXEC")
-    let normalToolchain = DarwinToolchain(env: env)
-    let normalSwiftPath = try normalToolchain.getToolPath(.swiftCompiler)
+    // DarwinToolchain
+    env.removeValue(forKey: envVarName)
+    let normalSwiftPath = try DarwinToolchain(env: env).getToolPath(.swiftCompiler)
     XCTAssertEqual(normalSwiftPath.basenameWithoutExt, "swift")
 
-    env["SWIFT_DRIVER_SWIFT_EXEC"] = "/some/garbage/path/fnord"
-    let overriddenToolchain = DarwinToolchain(env: env)
-    let overriddenSwiftPath = try overriddenToolchain.getToolPath(.swiftCompiler)
-    XCTAssertEqual(overriddenSwiftPath, AbsolutePath("/some/garbage/path/fnord"))
+    env[envVarName] = dummyPath
+    let overriddenSwiftPath = try DarwinToolchain(env: env).getToolPath(.swiftCompiler)
+    XCTAssertEqual(overriddenSwiftPath, AbsolutePath(dummyPath))
+    
+    // GenericUnixToolchain
+    env.removeValue(forKey: envVarName)
+    let unixSwiftPath = try GenericUnixToolchain(env: env).getToolPath(.swiftCompiler)
+    XCTAssertEqual(unixSwiftPath.basenameWithoutExt, "swift")
+    
+    env[envVarName] = dummyPath
+    let unixOverriddenSwiftPath = try GenericUnixToolchain(env: env).getToolPath(.swiftCompiler)
+    XCTAssertEqual(unixOverriddenSwiftPath, AbsolutePath(dummyPath))
   }
 }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -546,7 +546,7 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertFalse(cmd.contains(.flag("-dylib")))
       XCTAssertFalse(cmd.contains(.flag("-shared")))
     }
-
+    
     do {
       // linux target
       var driver = try Driver(args: commonArgs + ["-emit-library", "-target", "x86_64-unknown-linux"])