Merge branch 'main' into revert-1077-revert-991-disfavor-cwd

Author: stevapple

Sources/CSwiftScan/include/swiftscan_header.h

@@ -43,6 +43,18 @@ typedef struct swiftscan_module_details_s *swiftscan_module_details_t;
 typedef struct swiftscan_dependency_info_s *swiftscan_dependency_info_t;
 typedef struct swiftscan_dependency_graph_s *swiftscan_dependency_graph_t;
 typedef struct swiftscan_import_set_s *swiftscan_import_set_t;
+typedef struct swiftscan_diagnostic_info_s *swiftscan_diagnostic_info_t;
+
+typedef enum {
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR = 0,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING = 1,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_NOTE = 2,
+  SWIFTSCAN_DIAGNOSTIC_SEVERITY_REMARK = 3
+} swiftscan_diagnostic_severity_t;
+typedef struct {
+  swiftscan_diagnostic_info_t *diagnostics;
+  size_t count;
+} swiftscan_diagnostic_set_t;
 typedef struct {
   swiftscan_dependency_info_t *modules;
   size_t count;
@@ -210,6 +222,18 @@ typedef struct {
                                         swiftscan_scan_invocation_t);
   swiftscan_import_set_t
   (*swiftscan_import_set_create)(swiftscan_scanner_t, swiftscan_scan_invocation_t);
+  
+  //=== Scanner Diagnostics -------------------------------------------------===//
+  swiftscan_diagnostic_set_t*
+  (*swiftscan_scanner_diagnostics_query)(swiftscan_scanner_t);
+  void
+  (*swiftscan_scanner_diagnostics_reset)(swiftscan_scanner_t);
+  swiftscan_string_ref_t
+  (*swiftscan_diagnostic_get_message)(swiftscan_diagnostic_info_t);
+  swiftscan_diagnostic_severity_t
+  (*swiftscan_diagnostic_get_severity)(swiftscan_diagnostic_info_t);
+  void
+  (*swiftscan_diagnostics_set_dispose)(swiftscan_diagnostic_set_t*);
 
   //=== Scanner Cache Functions ---------------------------------------------===//
   void (*swiftscan_scanner_cache_serialize)(swiftscan_scanner_t scanner, const char * path);

Sources/SwiftDriver/CMakeLists.txt

@@ -97,6 +97,9 @@ add_library(SwiftDriver
   Toolchains/WebAssemblyToolchain.swift
   Toolchains/WindowsToolchain.swift
 
+  ToolingInterface/SimpleExecutor.swift
+  ToolingInterface/ToolingUtil.swift
+
   Utilities/DOTJobGraphSerializer.swift
   Utilities/DOTModuleDependencyGraphSerializer.swift
   Utilities/DateAdditions.swift

Sources/SwiftDriver/Driver/Driver.swift

@@ -562,7 +562,7 @@ public struct Driver {
                                  swiftCompilerPrefixArgs: self.swiftCompilerPrefixArgs)
 
     // Classify and collect all of the input files.
-    let inputFiles = try Self.collectInputFiles(&self.parsedOptions, diagnosticsEngine: diagnosticsEngine)
+    let inputFiles = try Self.collectInputFiles(&self.parsedOptions, diagnosticsEngine: diagnosticsEngine, fileSystem: self.fileSystem)
     self.inputFiles = inputFiles
     self.recordedInputModificationDates = .init(uniqueKeysWithValues:
       Set(inputFiles).compactMap {
@@ -634,6 +634,7 @@ public struct Driver {
                                fileSystem: fileSystem,
                                workingDirectory: workingDirectory,
                                diagnosticEngine: diagnosticEngine)
+    Self.validateEmitDependencyGraphArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
     Self.validateParseableOutputArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
     Self.validateCompilationConditionArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
     Self.validateFrameworkSearchPathArgs(&parsedOptions, diagnosticEngine: diagnosticEngine)
@@ -1247,7 +1248,7 @@ extension Driver {
   }
 
   /// Expand response files in the input arguments and return a new argument list.
-  @_spi(Testing) public static func expandResponseFiles(
+  public static func expandResponseFiles(
     _ args: [String],
     fileSystem: FileSystem,
     diagnosticsEngine: DiagnosticsEngine
@@ -1790,10 +1791,11 @@ extension Driver {
   /// Collect all of the input files from the parsed options, translating them into input files.
   private static func collectInputFiles(
     _ parsedOptions: inout ParsedOptions,
-    diagnosticsEngine: DiagnosticsEngine
+    diagnosticsEngine: DiagnosticsEngine,
+    fileSystem: FileSystem
   ) throws -> [TypedVirtualPath] {
     var swiftFiles = [String: String]() // [Basename: Path]
-    return try parsedOptions.allInputs.map { input in
+    var paths: [TypedVirtualPath] = try parsedOptions.allInputs.map { input in
       // Standard input is assumed to be Swift code.
       if input == "-" {
         return TypedVirtualPath(file: .standardInput, type: .swift)
@@ -1823,6 +1825,29 @@ extension Driver {
 
       return TypedVirtualPath(file: inputHandle, type: fileType)
     }
+    
+    if parsedOptions.hasArgument(.e) {
+      if let mainPath = swiftFiles["main.swift"] {
+        diagnosticsEngine.emit(.error_two_files_same_name(basename: "main.swift", firstPath: mainPath, secondPath: "-e"))
+        diagnosticsEngine.emit(.note_explain_two_files_same_name)
+        throw Diagnostics.fatalError
+      }
+      
+      try withTemporaryDirectory(dir: fileSystem.tempDirectory, removeTreeOnDeinit: false) { absPath in
+        let filePath = VirtualPath.absolute(absPath.appending(component: "main.swift"))
+        
+        try fileSystem.writeFileContents(filePath) { file in
+          file <<< ###"#sourceLocation(file: "-e", line: 1)\###n"###
+          for option in parsedOptions.arguments(for: .e) {
+            file <<< option.argument.asSingle <<< "\n"
+          }
+        }
+        
+        paths.append(TypedVirtualPath(file: filePath.intern(), type: .swift))
+      }
+    }
+    
+    return paths
   }
 
   /// Determine the primary compiler and linker output kinds.
@@ -2646,6 +2671,28 @@ extension Driver {
     }
   }
 
+  static func validateEmitDependencyGraphArgs(_ parsedOptions: inout ParsedOptions,
+                                              diagnosticEngine: DiagnosticsEngine) {
+    // '-print-explicit-dependency-graph' requires '-explicit-module-build'
+    if parsedOptions.hasArgument(.printExplicitDependencyGraph) &&
+        !parsedOptions.hasArgument(.driverExplicitModuleBuild) {
+      diagnosticEngine.emit(Error.optionRequiresAnother(Option.printExplicitDependencyGraph.spelling,
+                                                        Option.driverExplicitModuleBuild.spelling))
+    }
+    // '-explicit-dependency-graph-format=' requires '-print-explicit-dependency-graph'
+    if parsedOptions.hasArgument(.explicitDependencyGraphFormat) &&
+        !parsedOptions.hasArgument(.printExplicitDependencyGraph) {
+      diagnosticEngine.emit(Error.optionRequiresAnother(Option.explicitDependencyGraphFormat.spelling,
+                                                        Option.printExplicitDependencyGraph.spelling))
+    }
+    // '-explicit-dependency-graph-format=' only supports values 'json' and 'dot'
+    if let formatArg = parsedOptions.getLastArgument(.explicitDependencyGraphFormat)?.asSingle {
+      if formatArg != "json" && formatArg != "dot" {
+        diagnosticEngine.emit(.error_unsupported_argument(argument: formatArg,
+                                                          option: .explicitDependencyGraphFormat))
+      }
+    }
+  }
 
   static func validateProfilingArgs(_ parsedOptions: inout ParsedOptions,
                                     fileSystem: FileSystem,

Sources/SwiftDriver/ExplicitModuleBuilds/InterModuleDependencies/InterModuleDependencyOracle.swift

@@ -118,6 +118,25 @@ public class InterModuleDependencyOracle {
       swiftScan.resetScannerCache()
     }
   }
+  
+  @_spi(Testing) public func supportsScannerDiagnostics() throws -> Bool {
+    guard let swiftScan = swiftScanLibInstance else {
+      fatalError("Attempting to reset scanner cache with no scanner instance.")
+    }
+    return swiftScan.supportsScannerDiagnostics()
+  }
+  
+  @_spi(Testing) public func getScannerDiagnostics() throws -> [ScannerDiagnosticPayload]? {
+    guard let swiftScan = swiftScanLibInstance else {
+      fatalError("Attempting to reset scanner cache with no scanner instance.")
+    }
+    guard swiftScan.supportsScannerDiagnostics() else {
+      return nil
+    }
+    let diags = try swiftScan.queryScannerDiagnostics()
+    try swiftScan.resetScannerDiagnostics()
+    return diags.isEmpty ? nil : diags
+  }
 
   private var hasScannerInstance: Bool { self.swiftScanLibInstance != nil }
 

Sources/SwiftDriver/ExplicitModuleBuilds/ModuleDependencyScanning.swift

@@ -27,6 +27,18 @@ extension Diagnostic.Message {
   static func warn_scanner_frontend_fallback() -> Diagnostic.Message {
     .warning("Fallback to `swift-frontend` dependency scanner invocation")
   }
+  static func scanner_diagnostic_error(_ message: String) -> Diagnostic.Message {
+    .error("Dependency scanning failure: \(message)")
+  }
+  static func scanner_diagnostic_warn(_ message: String) -> Diagnostic.Message {
+    .warning(message)
+  }
+  static func scanner_diagnostic_note(_ message: String) -> Diagnostic.Message {
+    .note(message)
+  }
+  static func scanner_diagnostic_remark(_ message: String) -> Diagnostic.Message {
+    .remark(message)
+  }
 }
 
 public extension Driver {
@@ -177,6 +189,23 @@ public extension Driver {
         try interModuleDependencyOracle.getDependencies(workingDirectory: cwd,
                                                         moduleAliases: moduleOutputInfo.aliases,
                                                         commandLine: command)
+      let possibleDiags = try interModuleDependencyOracle.getScannerDiagnostics()
+      if let diags = possibleDiags {
+        for diagnostic in diags {
+          switch diagnostic.severity {
+          case .error:
+            diagnosticEngine.emit(.scanner_diagnostic_error(diagnostic.message))
+          case .warning:
+            diagnosticEngine.emit(.scanner_diagnostic_warn(diagnostic.message))
+          case .note:
+            diagnosticEngine.emit(.scanner_diagnostic_note(diagnostic.message))
+          case .remark:
+            diagnosticEngine.emit(.scanner_diagnostic_remark(diagnostic.message))
+          case .ignored:
+            diagnosticEngine.emit(.scanner_diagnostic_error(diagnostic.message))
+          }
+        }
+      }
     } else {
       // Fallback to legacy invocation of the dependency scanner with
       // `swift-frontend -scan-dependencies`

Sources/SwiftDriver/Jobs/Planning.swift

@@ -660,7 +660,12 @@ extension Driver {
     try resolveDependencyModulePaths(dependencyGraph: &dependencyGraph)
 
     if parsedOptions.hasArgument(.printExplicitDependencyGraph) {
-      try stdoutStream <<< dependencyGraph.toJSONString()
+      let outputFormat = parsedOptions.getLastArgument(.explicitDependencyGraphFormat)?.asSingle
+      if outputFormat == nil || outputFormat == "json" {
+        try stdoutStream <<< dependencyGraph.toJSONString()
+      } else if outputFormat == "dot" {
+        DOTModuleDependencyGraphSerializer(dependencyGraph).writeDOT(to: &stdoutStream)
+      }
       stdoutStream.flush()
     }
 

Sources/SwiftDriver/Jobs/WindowsToolchain+LinkerSupport.swift

@@ -44,9 +44,9 @@ extension WindowsToolchain {
       let librarian: String
       switch parsedOptions.getLastArgument(.useLd)?.asSingle {
       case .none:
-        librarian = lto == nil ? "link.exe" : "lld-link.exe"
+        librarian = lto == nil ? "link" : "lld-link"
       case .some("lld"), .some("lld.exe"), .some("lld-link"), .some("lld-link.exe"):
-        librarian = "lld-link.exe"
+        librarian = "lld-link"
       case let .some(linker):
         librarian = linker
       }

Sources/SwiftDriver/SwiftScan/SwiftScan.swift

@@ -18,6 +18,7 @@ import func Foundation.free
 import protocol TSCBasic.DiagnosticData
 import struct TSCBasic.AbsolutePath
 import struct TSCUtility.Version
+import struct TSCBasic.Diagnostic
 
 public enum DependencyScanningError: Error, DiagnosticData {
   case missingRequiredSymbol(String)
@@ -57,6 +58,28 @@ public enum DependencyScanningError: Error, DiagnosticData {
   }
 }
 
+@_spi(Testing) public struct ScannerDiagnosticPayload {
+  @_spi(Testing) public let severity: Diagnostic.Behavior
+  @_spi(Testing) public let message: String
+}
+
+internal extension swiftscan_diagnostic_severity_t {
+  func toDiagnosticBehavior() -> Diagnostic.Behavior {
+    switch self {
+    case SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR:
+      return Diagnostic.Behavior.error
+    case SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING:
+      return Diagnostic.Behavior.warning
+    case SWIFTSCAN_DIAGNOSTIC_SEVERITY_NOTE:
+      return Diagnostic.Behavior.note
+    case SWIFTSCAN_DIAGNOSTIC_SEVERITY_REMARK:
+      return Diagnostic.Behavior.remark
+    default:
+      return Diagnostic.Behavior.error
+    }
+  }
+}
+
 /// Wrapper for libSwiftScan, taking care of initialization, shutdown, and dispatching dependency scanning queries.
 internal final class SwiftScan {
   /// The path to the libSwiftScan dylib.
@@ -235,6 +258,41 @@ internal final class SwiftScan {
   func resetScannerCache() {
     api.swiftscan_scanner_cache_reset(scanner)
   }
+  
+  @_spi(Testing) public func supportsScannerDiagnostics() -> Bool {
+    return api.swiftscan_scanner_diagnostics_query != nil &&
+           api.swiftscan_scanner_diagnostics_reset != nil &&
+           api.swiftscan_diagnostic_get_message != nil &&
+           api.swiftscan_diagnostic_get_severity != nil &&
+           api.swiftscan_diagnostics_set_dispose != nil
+  }
+  
+  @_spi(Testing) public func queryScannerDiagnostics() throws -> [ScannerDiagnosticPayload] {
+    var result: [ScannerDiagnosticPayload] = []
+    let diagnosticSetRefOrNull = api.swiftscan_scanner_diagnostics_query(scanner)
+    guard let diagnosticSetRef = diagnosticSetRefOrNull else {
+      // Seems heavy-handed to fail here
+      // throw DependencyScanningError.dependencyScanFailed
+      return []
+    }
+    defer { api.swiftscan_diagnostics_set_dispose(diagnosticSetRef) }
+    let diagnosticRefArray = Array(UnsafeBufferPointer(start: diagnosticSetRef.pointee.diagnostics,
+                                                       count: Int(diagnosticSetRef.pointee.count)))
+    
+    for diagnosticRefOrNull in diagnosticRefArray {
+      guard let diagnosticRef = diagnosticRefOrNull else {
+        throw DependencyScanningError.dependencyScanFailed
+      }
+      let message = try toSwiftString(api.swiftscan_diagnostic_get_message(diagnosticRef))
+      let severity = api.swiftscan_diagnostic_get_severity(diagnosticRef)
+      result.append(ScannerDiagnosticPayload(severity: severity.toDiagnosticBehavior(), message: message))
+    }
+    return result
+  }
+  
+  @_spi(Testing) public func resetScannerDiagnostics() throws {
+    api.swiftscan_scanner_diagnostics_reset(scanner)
+  }
 
   @_spi(Testing) public func canQuerySupportedArguments() -> Bool {
     return api.swiftscan_compiler_supported_arguments_query != nil &&
@@ -300,6 +358,18 @@ private extension swiftscan_functions_t {
     // Clang dependency captured PCM args
     self.swiftscan_clang_detail_get_captured_pcm_args =
       try loadOptional("swiftscan_clang_detail_get_captured_pcm_args")
+    
+    // Scanner diagnostic emission query
+    self.swiftscan_scanner_diagnostics_query =
+      try loadOptional("swiftscan_scanner_diagnostics_query")
+    self.swiftscan_scanner_diagnostics_reset =
+      try loadOptional("swiftscan_scanner_diagnostics_reset")
+    self.swiftscan_diagnostic_get_message =
+      try loadOptional("swiftscan_diagnostic_get_message")
+    self.swiftscan_diagnostic_get_severity =
+      try loadOptional("swiftscan_diagnostic_get_severity")
+    self.swiftscan_diagnostics_set_dispose =
+      try loadOptional("swiftscan_diagnostics_set_dispose")
 
     // MARK: Required Methods
     func loadRequired<T>(_ symbol: String) throws -> T {

Sources/SwiftDriver/Toolchains/Toolchain.swift

@@ -191,11 +191,7 @@ extension Toolchain {
 
   /// - Returns: String in the form of: `SWIFT_DRIVER_TOOLNAME_EXEC`
   private func envVarName(for toolName: String) -> String {
-    var lookupName = toolName
-#if os(Windows)
-    lookupName = lookupName.replacingOccurrences(of: ".exe", with: "")
-#endif
-    lookupName = lookupName.replacingOccurrences(of: "-", with: "_").uppercased()
+    let lookupName = toolName.replacingOccurrences(of: "-", with: "_").uppercased()
     return "SWIFT_DRIVER_\(lookupName)_EXEC"
   }
 
@@ -209,9 +205,9 @@ extension Toolchain {
 
   /// Looks for the executable in the `SWIFT_DRIVER_TOOLNAME_EXEC` environment variable, if found nothing,
   /// looks in the `executableDir`, `xcrunFind` or in the `searchPaths`.
-  /// - Parameter executable: executable to look for [i.e. `swift`].
+  /// - Parameter executable: executable to look for [i.e. `swift`]. Executable suffix (eg. `.exe`) should be omitted.
   func lookup(executable: String) throws -> AbsolutePath {
-    if let overrideString = envVar(forExecutable: executableName(executable)),
+    if let overrideString = envVar(forExecutable: executable),
        let path = try? AbsolutePath(validating: overrideString) {
       return path
     } else if let toolDir = toolDirectory,
@@ -222,7 +218,7 @@ extension Toolchain {
       return path
     } else if let path = try? xcrunFind(executable: executableName(executable)) {
       return path
-    } else if !["swift-frontend", "swift", "swift-frontend.exe", "swift.exe"].contains(executable),
+    } else if !["swift-frontend", "swift"].contains(executable),
               let parentDirectory = try? getToolPath(.swiftCompiler).parentDirectory,
               parentDirectory != executableDir,
               let path = lookupExecutablePath(filename: executableName(executable), searchPaths: [parentDirectory]) {
@@ -231,14 +227,14 @@ extension Toolchain {
       return path
     } else if let path = lookupExecutablePath(filename: executableName(executable), searchPaths: searchPaths) {
       return path
-    } else if executable == executableName("swift-frontend") {
+    } else if executable == "swift-frontend" {
       // Temporary shim: fall back to looking for "swift" before failing.
-      return try lookup(executable: executableName("swift"))
+      return try lookup(executable: "swift")
     } else if fallbackToExecutableDefaultPath {
       if self is WindowsToolchain {
         return try getToolPath(.swiftCompiler)
                 .parentDirectory
-                .appending(component: executable)
+                .appending(component: executableName(executable))
       } else {
         return AbsolutePath("/usr/bin/" + executable)
       }