Revert "Allow for non-external lookup of libSwiftScan symbols and centralize …"

This reverts commit d616136.

Author: artemcm

Sources/SwiftDriver/Driver/Driver.swift

@@ -80,7 +80,7 @@ public struct DriverExecutorWorkload {
   }
 }
 
-@_spi(Testing) public enum JobExecutionError: Error {
+enum JobExecutionError: Error {
   case jobFailedWithNonzeroExitCode(Int, String)
   case failedToReadJobOutput
   // A way to pass more information to the catch point

Sources/SwiftDriver/Execution/DriverExecutor.swift

@@ -83,17 +83,16 @@ public class InterModuleDependencyOracle {
   }
 
   /// Given a specified toolchain path, locate and instantiate an instance of the SwiftScan library
-  public func verifyOrCreateScannerInstance(swiftScanLibPath: AbsolutePath?) throws {
+  public func verifyOrCreateScannerInstance(fileSystem: FileSystem,
+                                            swiftScanLibPath: AbsolutePath) throws {
     return try queue.sync {
-      guard let scanInstance = swiftScanLibInstance else {
+      if swiftScanLibInstance == nil {
         swiftScanLibInstance = try SwiftScan(dylib: swiftScanLibPath)
-        return
-      }
-
-      guard scanInstance.path?.description == swiftScanLibPath?.description else {
-        throw DependencyScanningError
-          .scanningLibraryInvocationMismatch(scanInstance.path?.description ?? "built-in",
-                                             swiftScanLibPath?.description ?? "built-in")
+      } else {
+        guard swiftScanLibInstance!.path == swiftScanLibPath else {
+          throw DependencyScanningError
+          .scanningLibraryInvocationMismatch(swiftScanLibInstance!.path, swiftScanLibPath)
+        }
       }
     }
   }
@@ -210,20 +209,10 @@ public class InterModuleDependencyOracle {
     }
   }
 
-  // Note: this is `true` even in the `compilerIntegratedTooling` mode
-  // where the `SwiftScan` instance refers to the own image the driver is
-  // running in, since there is still technically a `SwiftScan` handle
-  // capable of handling API requests expected of it.
   private var hasScannerInstance: Bool { self.swiftScanLibInstance != nil }
-  func getScannerInstance() -> SwiftScan? {
-    self.swiftScanLibInstance
-  }
-  func setScannerInstance(_ instance: SwiftScan?) {
-    self.swiftScanLibInstance = instance
-  }
 
   /// Queue to sunchronize accesses to the scanner
-  let queue = DispatchQueue(label: "org.swift.swift-driver.swift-scan")
+  internal let queue = DispatchQueue(label: "org.swift.swift-driver.swift-scan")
 
   /// A reference to an instance of the compiler's libSwiftScan shared library
   private var swiftScanLibInstance: SwiftScan? = nil

Sources/SwiftDriver/ExplicitModuleBuilds/InterModuleDependencies/InterModuleDependencyOracle.swift

@@ -164,6 +164,41 @@ public extension Driver {
                                                                        contents)
   }
 
+  /// Returns false if the lib is available and ready to use
+  private mutating func initSwiftScanLib() throws -> Bool {
+    // `-nonlib-dependency-scanner` was specified
+    guard !parsedOptions.hasArgument(.driverScanDependenciesNonLib) else {
+      return true
+    }
+
+    // If the libSwiftScan library cannot be found,
+    // attempt to fallback to using `swift-frontend -scan-dependencies` invocations for dependency
+    // scanning.
+    guard let scanLibPath = try toolchain.lookupSwiftScanLib(),
+          fileSystem.exists(scanLibPath) else {
+      diagnosticEngine.emit(.warn_scan_dylib_not_found())
+      return true
+    }
+
+    do {
+      try interModuleDependencyOracle.verifyOrCreateScannerInstance(fileSystem: fileSystem,
+                                                                    swiftScanLibPath: scanLibPath)
+      if isCachingEnabled {
+        self.cas = try interModuleDependencyOracle.getOrCreateCAS(pluginPath: try getCASPluginPath(),
+                                                                  onDiskPath: try getOnDiskCASPath(),
+                                                                  pluginOptions: try getCASPluginOptions())
+      }
+    } catch {
+      if isCachingEnabled {
+        diagnosticEngine.emit(.error_caching_enabled_libswiftscan_load_failure(scanLibPath.description))
+      } else {
+        diagnosticEngine.emit(.warn_scan_dylib_load_failed(scanLibPath.description))
+      }
+      return true
+    }
+    return false
+  }
+
   static func sanitizeCommandForLibScanInvocation(_ command: inout [String]) {
     // Remove the tool executable to only leave the arguments. When passing the
     // command line into libSwiftScan, the library is itself the tool and only
@@ -182,7 +217,8 @@ public extension Driver {
     let forceResponseFiles = parsedOptions.hasArgument(.driverForceResponseFiles)
     let imports: InterModuleDependencyImports
 
-    if supportInProcessSwiftScanQueries {
+    let isSwiftScanLibAvailable = !(try initSwiftScanLib())
+    if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
       guard let cwd = workingDirectory else {
         throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
@@ -258,7 +294,8 @@ public extension Driver {
       stdoutStream.flush()
     }
 
-    if supportInProcessSwiftScanQueries {
+    let isSwiftScanLibAvailable = !(try initSwiftScanLib())
+    if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
       guard let cwd = workingDirectory else {
         throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
@@ -296,7 +333,8 @@ public extension Driver {
     let forceResponseFiles = parsedOptions.hasArgument(.driverForceResponseFiles)
     let moduleVersionedGraphMap: [ModuleDependencyId: [InterModuleDependencyGraph]]
 
-    if supportInProcessSwiftScanQueries {
+    let isSwiftScanLibAvailable = !(try initSwiftScanLib())
+    if isSwiftScanLibAvailable {
       var scanDiagnostics: [ScannerDiagnosticPayload] = []
       guard let cwd = workingDirectory else {
         throw DependencyScanningError.dependencyScanFailed("cannot determine working directory")
@@ -464,7 +502,3 @@ public extension Driver {
       .parentDirectory // toolchain root
   }
 }
-
-extension Driver {
-  var supportInProcessSwiftScanQueries: Bool { return self.swiftScanLibInstance != nil }
-}

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -59,19 +59,18 @@ extension Toolchain {
 extension Driver {
 
   static func computeSupportedCompilerArgs(of toolchain: Toolchain,
-                                           libSwiftScan: SwiftScan?,
                                            parsedOptions: inout ParsedOptions,
                                            diagnosticsEngine: DiagnosticsEngine,
                                            fileSystem: FileSystem,
                                            executor: DriverExecutor)
   throws -> Set<String> {
-    if let libSwiftScanInstance = libSwiftScan,
-       libSwiftScanInstance.canQuerySupportedArguments() {
-      do {
-        return try libSwiftScanInstance.querySupportedArguments()
-      } catch {
-        diagnosticsEngine.emit(.remark_inprocess_supported_features_query_failed(error.localizedDescription))
+    do {
+      if let supportedArgs =
+          try querySupportedCompilerArgsInProcess(of: toolchain, fileSystem: fileSystem) {
+        return supportedArgs
       }
+    } catch {
+      diagnosticsEngine.emit(.remark_inprocess_supported_features_query_failed(error.localizedDescription))
     }
 
     // Fallback: Invoke `swift-frontend -emit-supported-features` and decode the output
@@ -89,6 +88,20 @@ extension Driver {
     return Set(decodedSupportedFlagList)
   }
 
+  static func querySupportedCompilerArgsInProcess(of toolchain: Toolchain,
+                                                  fileSystem: FileSystem)
+  throws -> Set<String>? {
+    let optionalSwiftScanLibPath = try toolchain.lookupSwiftScanLib()
+    if let swiftScanLibPath = optionalSwiftScanLibPath,
+       fileSystem.exists(swiftScanLibPath) {
+      let libSwiftScanInstance = try SwiftScan(dylib: swiftScanLibPath)
+      if libSwiftScanInstance.canQuerySupportedArguments() {
+        return try libSwiftScanInstance.querySupportedArguments()
+      }
+    }
+    return nil
+  }
+
   static func computeSupportedCompilerFeatures(of toolchain: Toolchain,
                                                env: [String: String]) throws -> Set<String> {
     struct FeatureInfo: Codable {

Sources/SwiftDriver/Jobs/EmitSupportedFeaturesJob.swift

@@ -406,13 +406,11 @@ extension Driver {
     // CAS related options.
     if isCachingEnabled {
       commandLine.appendFlag(.cacheCompileJob)
-      if let casPath = try Self.getOnDiskCASPath(parsedOptions: &parsedOptions,
-                                                 toolchain: toolchain) {
+      if let casPath = try getOnDiskCASPath() {
         commandLine.appendFlag(.casPath)
         commandLine.appendFlag(casPath.pathString)
       }
-      if let pluginPath = try Self.getCASPluginPath(parsedOptions: &parsedOptions,
-                                                    toolchain: toolchain) {
+      if let pluginPath = try getCASPluginPath() {
         commandLine.appendFlag(.casPluginPath)
         commandLine.appendFlag(pluginPath.pathString)
       }

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -181,39 +181,46 @@ extension Toolchain {
 }
 
 extension Driver {
-  @_spi(Testing) public static func queryTargetInfoInProcess(libSwiftScanInstance: SwiftScan,
-                                                             toolchain: Toolchain,
+  @_spi(Testing) public static func queryTargetInfoInProcess(of toolchain: Toolchain,
                                                              fileSystem: FileSystem,
                                                              workingDirectory: AbsolutePath?,
-                                                             invocationCommand: [String]) throws -> FrontendTargetInfo {
-    let cwd = try workingDirectory ?? fileSystem.tempDirectory
-    let compilerExecutablePath = try toolchain.resolvedTool(.swiftCompiler).path
-    let targetInfoData =
-    try libSwiftScanInstance.queryTargetInfoJSON(workingDirectory: cwd,
-                                                 compilerExecutablePath: compilerExecutablePath,
-                                                 invocationCommand: invocationCommand)
-    do {
-      return try JSONDecoder().decode(FrontendTargetInfo.self, from: targetInfoData)
-    } catch let decodingError as DecodingError {
-      let stringToDecode = String(data: targetInfoData, encoding: .utf8)
-      let errorDesc: String
-      switch decodingError {
-      case let .typeMismatch(type, context):
-        errorDesc = "type mismatch: \(type), path: \(context.codingPath)"
-      case let .valueNotFound(type, context):
-        errorDesc = "value missing: \(type), path: \(context.codingPath)"
-      case let .keyNotFound(key, context):
-        errorDesc = "key missing: \(key), path: \(context.codingPath)"
-      case let .dataCorrupted(context):
-        errorDesc = "data corrupted at path: \(context.codingPath)"
-      @unknown default:
-        errorDesc = "unknown decoding error"
+                                                             invocationCommand: [String]) throws -> FrontendTargetInfo? {
+    let optionalSwiftScanLibPath = try toolchain.lookupSwiftScanLib()
+    if let swiftScanLibPath = optionalSwiftScanLibPath,
+       fileSystem.exists(swiftScanLibPath) {
+      let libSwiftScanInstance = try SwiftScan(dylib: swiftScanLibPath)
+      if libSwiftScanInstance.canQueryTargetInfo() {
+        let cwd = try workingDirectory ?? fileSystem.tempDirectory
+        let compilerExecutablePath = try toolchain.resolvedTool(.swiftCompiler).path
+        let targetInfoData =
+          try libSwiftScanInstance.queryTargetInfoJSON(workingDirectory: cwd,
+                                                       compilerExecutablePath: compilerExecutablePath,
+                                                       invocationCommand: invocationCommand)
+        do {
+          return try JSONDecoder().decode(FrontendTargetInfo.self, from: targetInfoData)
+        } catch let decodingError as DecodingError {
+          let stringToDecode = String(data: targetInfoData, encoding: .utf8)
+          let errorDesc: String
+          switch decodingError {
+            case let .typeMismatch(type, context):
+              errorDesc = "type mismatch: \(type), path: \(context.codingPath)"
+            case let .valueNotFound(type, context):
+              errorDesc = "value missing: \(type), path: \(context.codingPath)"
+            case let .keyNotFound(key, context):
+              errorDesc = "key missing: \(key), path: \(context.codingPath)"
+           case let .dataCorrupted(context):
+              errorDesc = "data corrupted at path: \(context.codingPath)"
+            @unknown default:
+              errorDesc = "unknown decoding error"
+          }
+          throw Error.unableToDecodeFrontendTargetInfo(
+            stringToDecode,
+            invocationCommand,
+            errorDesc)
+        }
       }
-      throw Error.unableToDecodeFrontendTargetInfo(
-        stringToDecode,
-        invocationCommand,
-        errorDesc)
     }
+    return nil
   }
 
   static func computeTargetInfo(target: Triple?,
@@ -224,7 +231,6 @@ extension Driver {
                                 requiresInPlaceExecution: Bool = false,
                                 useStaticResourceDir: Bool = false,
                                 swiftCompilerPrefixArgs: [String],
-                                libSwiftScan: SwiftScan?,
                                 toolchain: Toolchain,
                                 fileSystem: FileSystem,
                                 workingDirectory: AbsolutePath?,
@@ -237,19 +243,20 @@ extension Driver {
                                        requiresInPlaceExecution: requiresInPlaceExecution,
                                        useStaticResourceDir: useStaticResourceDir,
                                        swiftCompilerPrefixArgs: swiftCompilerPrefixArgs)
-    if let libSwiftScanInstance = libSwiftScan,
-       libSwiftScanInstance.canQueryTargetInfo() {
-      do {
-        var command = try Self.itemizedJobCommand(of: frontendTargetInfoJob,
-                                                  useResponseFiles: .disabled,
-                                                  using: executor.resolver)
-        Self.sanitizeCommandForLibScanInvocation(&command)
-        return try Self.queryTargetInfoInProcess(libSwiftScanInstance: libSwiftScanInstance, toolchain: toolchain,
-                                                 fileSystem: fileSystem, workingDirectory: workingDirectory,
-                                                 invocationCommand: command)
-      } catch {
-        diagnosticsEngine.emit(.remark_inprocess_target_info_query_failed(error.localizedDescription))
+    var command = try Self.itemizedJobCommand(of: frontendTargetInfoJob,
+                                              useResponseFiles: .disabled,
+                                              using: executor.resolver)
+    Self.sanitizeCommandForLibScanInvocation(&command)
+
+    do {
+      if let targetInfo =
+          try Self.queryTargetInfoInProcess(of: toolchain, fileSystem: fileSystem,
+                                            workingDirectory: workingDirectory,
+                                            invocationCommand: command) {
+        return targetInfo
       }
+    } catch {
+      diagnosticsEngine.emit(.remark_inprocess_target_info_query_failed(error.localizedDescription))
     }
 
     // Fallback: Invoke `swift-frontend -print-target-info` and decode the output

Sources/SwiftDriver/Jobs/PrintTargetInfoJob.swift

@@ -161,19 +161,6 @@ extension Loader {
     return Handle(value: handle)
   }
 
-  public static func getSelfHandle(mode: Flags) throws -> Handle {
-#if os(Windows)
-    guard let handle = GetModuleHandleW(nil) else  {
-      throw Loader.Error.open("GetModuleHandleW(nil) failure: \(GetLastError())")
-    }
-#else
-    guard let handle = dlopen(nil, mode.rawValue) else {
-      throw Loader.Error.open(Loader.error() ?? "unknown error")
-    }
-#endif
-    return Handle(value: handle)
-  }
-
   public static func lookup<T>(symbol: String, in module: Handle) -> T? {
 #if os(Windows)
     guard let pointer = GetProcAddress(module.value!, symbol) else {