Use target-platform-specific shared library file extension. (.so except for Darwin)

Author: artemcm

Sources/SwiftDriver/ExplicitModuleBuilds/ExplicitDependencyBuildPlanner.swift

@@ -35,7 +35,7 @@ public typealias ExternalBuildArtifacts = (ExternalTargetModulePathMap, ModuleIn
   /// The toolchain to be used for frontend job generation.
   private let toolchain: Toolchain
 
-  /// Whether we are using the integrated driver via libSwiftDriver.dylib
+  /// Whether we are using the integrated driver via libSwiftDriver shared lib
   private let integratedDriver: Bool
   private let mainModuleName: String?
 

Sources/SwiftDriver/ExplicitModuleBuilds/InterModuleDependencies/InterModuleDependencyOracle.swift

@@ -54,19 +54,11 @@ public class InterModuleDependencyOracle {
 
   /// Given a specified toolchain path, locate and instantiate an instance of the SwiftScan library
   @_spi(Testing) public func verifyOrCreateScannerInstance(fileSystem: FileSystem,
-                                                           toolchainPath: AbsolutePath,
-                                                           osName: String) throws {
+                                                           swiftScanLibPath: AbsolutePath) throws {
     try queue.sync {
-      let swiftScanLibPath = toolchainPath.appending(component: "lib")
-        .appending(component: "swift")
-        .appending(component: osName)
-        .appending(component: "lib_InternalSwiftScan.dylib")
       if swiftScanLibInstance == nil {
-        guard fileSystem.exists(toolchainPath) else {
-          fatalError("Path to specified toolchain does not exist: \(toolchainPath.description)")
-        }
-        guard fileSystem.exists(toolchainPath) else {
-          fatalError("Could not find libSwiftScan at: \(swiftScanLibPath.description)")
+        guard fileSystem.exists(swiftScanLibPath) else {
+          throw DependencyScanningError.scanningLibraryNotFound(swiftScanLibPath)
         }
         swiftScanLibInstance = try SwiftScan(dylib: swiftScanLibPath)
       } else {

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -96,8 +96,8 @@ internal extension Driver {
     if (!parsedOptions.hasArgument(.driverScanDependenciesNonLib)) {
       try interModuleDependencyOracle
         .verifyOrCreateScannerInstance(fileSystem: fileSystem,
-                                       toolchainPath: try getRootPath(of: toolchain),
-                                       osName: targetTriple.osNameUnversioned)
+                                       swiftScanLibPath: try getScanLibPath(of: toolchain,
+                                                                            target: targetTriple))
       let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory!
       var command = try itemizedJobCommand(of: scannerJob,
                                            forceResponseFiles: forceResponseFiles,
@@ -130,8 +130,8 @@ internal extension Driver {
     if (!parsedOptions.hasArgument(.driverScanDependenciesNonLib)) {
       try interModuleDependencyOracle
         .verifyOrCreateScannerInstance(fileSystem: fileSystem,
-                                       toolchainPath: try getRootPath(of: toolchain),
-                                       osName: targetTriple.osNameUnversioned)
+                                       swiftScanLibPath: try getScanLibPath(of: toolchain,
+                                                                            target: targetTriple))
       let cwd = workingDirectory ?? fileSystem.currentWorkingDirectory!
       var command = try itemizedJobCommand(of: batchScanningJob,
                                            forceResponseFiles: forceResponseFiles,
@@ -261,6 +261,21 @@ internal extension Driver {
                                                      quotePaths: true)
     return args
   }
+}
+
+@_spi(Testing) public extension Driver {
+  func getScanLibPath(of toolchain: Toolchain, target: Triple) throws -> AbsolutePath {
+    let sharedLibExt: String
+    if target.isMacOSX {
+      sharedLibExt = ".dylib"
+    } else {
+      sharedLibExt = ".so"
+    }
+    return try getRootPath(of: toolchain).appending(component: "lib")
+      .appending(component: "swift")
+      .appending(component: target.osNameUnversioned)
+      .appending(component: "lib_InternalSwiftScan" + sharedLibExt)
+  }
 
   fileprivate func getRootPath(of toolchain: Toolchain) throws -> AbsolutePath {
     if let overrideString = env["SWIFT_DRIVER_SWIFT_SCAN_TOOLCHAIN_PATH"] {

Sources/SwiftDriver/SwiftScan/SwiftScan.swift

@@ -25,6 +25,7 @@ public enum DependencyScanningError: Error, DiagnosticData {
   case unsupportedDependencyDetailsKind(Int)
   case invalidStringPtr
   case scanningLibraryInvocationMismatch(AbsolutePath, AbsolutePath)
+  case scanningLibraryNotFound(AbsolutePath)
 
   public var description: String {
     switch self {
@@ -43,7 +44,9 @@ public enum DependencyScanningError: Error, DiagnosticData {
       case .invalidStringPtr:
         return "Dependency module details contains a corrupted string reference"
       case .scanningLibraryInvocationMismatch(let path1, let path2):
-        return "Module scanning library differs across driver invocations: \(path1.description) and \(path2.description)"
+        return "Dependency Scanning library differs across driver invocations: \(path1.description) and \(path2.description)"
+      case .scanningLibraryNotFound(let path):
+        return "Dependency Scanning library not found at path: \(path)"
     }
   }
 }

Tests/SwiftDriverTests/ExplicitModuleBuildTests.swift

@@ -160,14 +160,11 @@ final class ExplicitModuleBuildTests: XCTestCase {
             try JSONDecoder().decode(
               InterModuleDependencyGraph.self,
               from: ModuleDependenciesInputs.fastDependencyScannerOutput.data(using: .utf8)!)
-      let toolchainRootPath: AbsolutePath = try driver.toolchain.getToolPath(.swiftCompiler)
-                                                              .parentDirectory // bin
-                                                              .parentDirectory // toolchain root
       let dependencyOracle = InterModuleDependencyOracle()
       try dependencyOracle
         .verifyOrCreateScannerInstance(fileSystem: localFileSystem,
-                                       toolchainPath: toolchainRootPath,
-                                       osName: driver.targetTriple.osNameUnversioned)
+                                       swiftScanLibPath: try driver.getScanLibPath(of: driver.toolchain,
+                                                                                   target: driver.targetTriple))
       try dependencyOracle.mergeModules(from: moduleDependencyGraph)
       driver.explicitDependencyBuildPlanner =
         try ExplicitDependencyBuildPlanner(dependencyGraph: moduleDependencyGraph,
@@ -217,15 +214,6 @@ final class ExplicitModuleBuildTests: XCTestCase {
                                              processSet: ProcessSet(),
                                              fileSystem: localFileSystem,
                                              env: ProcessEnv.vars)
-      var toolchain: Toolchain
-      #if os(macOS)
-      toolchain = DarwinToolchain(env: ProcessEnv.vars, executor: executor)
-      #else
-      toolchain = GenericUnixToolchain(env: ProcessEnv.vars, executor: executor)
-      #endif
-      let toolchainRootPath: AbsolutePath = try toolchain.getToolPath(.swiftCompiler)
-                                                              .parentDirectory // bin
-                                                              .parentDirectory // toolchain root
       let dependencyOracle = InterModuleDependencyOracle()
       try dependencyOracle.mergeModules(from: inputDependencyGraph)
 
@@ -245,8 +233,8 @@ final class ExplicitModuleBuildTests: XCTestCase {
                               interModuleDependencyOracle: dependencyOracle)
       try dependencyOracle
         .verifyOrCreateScannerInstance(fileSystem: localFileSystem,
-                                       toolchainPath: toolchainRootPath,
-                                       osName: driver.targetTriple.osNameUnversioned)
+                                       swiftScanLibPath: try driver.getScanLibPath(of: driver.toolchain,
+                                                                                   target: driver.targetTriple))
 
       // Plan explicit dependency jobs, after resolving placeholders to actual dependencies.
       try moduleDependencyGraph.resolvePlaceholderDependencies(for: (targetModulePathMap, [:]),
@@ -533,8 +521,8 @@ final class ExplicitModuleBuildTests: XCTestCase {
     let dependencyOracle = InterModuleDependencyOracle()
     try dependencyOracle
       .verifyOrCreateScannerInstance(fileSystem: localFileSystem,
-                                     toolchainPath: toolchainRootPath,
-                                     osName: driver.targetTriple.osNameUnversioned)
+                                     swiftScanLibPath: try driver.getScanLibPath(of: driver.toolchain,
+                                                                                 target: driver.targetTriple))
 
     // Create a simple test case.
     try withTemporaryDirectory { path in