Merge pull request #84191 from artemcm/InMemoryDepScanSerializedDiagnostics

[Dependency Scanning] Configure a serialized diagnostics consumer for in-memory scans

Author: artemcm

include/swift/DependencyScan/DependencyScanningTool.h

@@ -15,20 +15,50 @@
 
 #include "swift-c/DependencyScan/DependencyScan.h"
 #include "swift/Frontend/Frontend.h"
+#include "swift/AST/DiagnosticConsumer.h"
 #include "swift/AST/ModuleDependencies.h"
 #include "swift/DependencyScan/ScanDependencies.h"
 #include "swift/Frontend/PrintingDiagnosticConsumer.h"
+#include "swift/Frontend/SerializedDiagnosticConsumer.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/StringSaver.h"
 
 namespace swift {
 namespace dependencies {
 class DependencyScanningTool;
-class DependencyScanDiagnosticCollector;
+class DepScanInMemoryDiagnosticCollector;
 
-struct ScanQueryInstance {
+struct ScanQueryContext {
+  /// Primary CompilerInstance configured for this scanning action
   std::unique_ptr<CompilerInstance> ScanInstance;
-  std::shared_ptr<DependencyScanDiagnosticCollector> ScanDiagnostics;
+  /// An thread-safe diagnostic consumer which collects all emitted
+  /// diagnostics in the scan to be reporte via libSwiftScan API
+  std::unique_ptr<DepScanInMemoryDiagnosticCollector> InMemoryDiagnosticCollector;
+  /// A thread-safe serialized diagnostics consumer.
+  /// Note, although type-erased, this must be an instance of
+  /// 'ThreadSafeSerializedDiagnosticConsumer'
+  std::unique_ptr<DiagnosticConsumer> SerializedDiagnosticConsumer;
+
+  ScanQueryContext(
+      std::unique_ptr<CompilerInstance> ScanInstance,
+      std::unique_ptr<DepScanInMemoryDiagnosticCollector>
+          InMemoryDiagnosticCollector,
+      std::unique_ptr<DiagnosticConsumer> SerializedDiagnosticConsumer)
+      : ScanInstance(std::move(ScanInstance)),
+        InMemoryDiagnosticCollector(std::move(InMemoryDiagnosticCollector)),
+        SerializedDiagnosticConsumer(std::move(SerializedDiagnosticConsumer)) {}
+
+  ScanQueryContext(ScanQueryContext &&other)
+      : ScanInstance(std::move(other.ScanInstance)),
+        InMemoryDiagnosticCollector(
+            std::move(other.InMemoryDiagnosticCollector)),
+        SerializedDiagnosticConsumer(
+            std::move(other.SerializedDiagnosticConsumer)) {}
+
+  ~ScanQueryContext() {
+    if (SerializedDiagnosticConsumer)
+      SerializedDiagnosticConsumer->finishProcessing();
+  }
 };
 
 /// Pure virtual Diagnostic consumer intended for collecting
@@ -47,12 +77,16 @@ class ThreadSafeDiagnosticCollector : public DiagnosticConsumer {
 };
 
 /// Diagnostic consumer that simply collects the diagnostics emitted so-far
-class DependencyScanDiagnosticCollector : public ThreadSafeDiagnosticCollector {
-private:
+/// and uses a representation agnostic from any specific CompilerInstance state
+/// which may have been used to emit the diagnostic
+class DepScanInMemoryDiagnosticCollector
+    : public ThreadSafeDiagnosticCollector {
+public:
   struct ScannerDiagnosticInfo {
     std::string Message;
     llvm::SourceMgr::DiagKind Severity;
-    std::optional<ScannerImportStatementInfo::ImportDiagnosticLocationInfo> ImportLocation;
+    std::optional<ScannerImportStatementInfo::ImportDiagnosticLocationInfo>
+        ImportLocation;
   };
   std::vector<ScannerDiagnosticInfo> Diagnostics;
 
@@ -61,9 +95,12 @@ class DependencyScanDiagnosticCollector : public ThreadSafeDiagnosticCollector {
 
 public:
   friend DependencyScanningTool;
-  DependencyScanDiagnosticCollector() {}
+  DepScanInMemoryDiagnosticCollector() {}
   void reset() { Diagnostics.clear(); }
-  const std::vector<ScannerDiagnosticInfo> &getDiagnostics() const {
+  std::vector<ScannerDiagnosticInfo> getDiagnostics() const {
+    return Diagnostics;
+  }
+  const std::vector<ScannerDiagnosticInfo> &getDiagnosticsRef() const {
     return Diagnostics;
   }
 };
@@ -97,10 +134,10 @@ class DependencyScanningTool {
 
   /// Using the specified invocation command, instantiate a CompilerInstance
   /// that will be used for this scan.
-  llvm::ErrorOr<ScanQueryInstance>
-  initCompilerInstanceForScan(ArrayRef<const char *> Command,
-                              StringRef WorkingDirectory,
-                              std::shared_ptr<DependencyScanDiagnosticCollector> scannerDiagnosticsCollector);
+  llvm::ErrorOr<ScanQueryContext> createScanQueryContext(
+      ArrayRef<const char *> Command, StringRef WorkingDirectory,
+      std::vector<DepScanInMemoryDiagnosticCollector::ScannerDiagnosticInfo>
+          &initializationDiagnostics);
 
 private:
   /// Shared cache of module dependencies, re-used by individual full-scan queries
@@ -113,7 +150,9 @@ class DependencyScanningTool {
   llvm::StringSaver Saver;
 };
 
-swiftscan_diagnostic_set_t *mapCollectedDiagnosticsForOutput(const DependencyScanDiagnosticCollector *diagnosticCollector);
+swiftscan_diagnostic_set_t *mapCollectedDiagnosticsForOutput(
+    ArrayRef<DepScanInMemoryDiagnosticCollector::ScannerDiagnosticInfo>
+        diagnostics);
 
 } // end namespace dependencies
 } // end namespace swift

include/swift/DependencyScan/ScanDependencies.h

@@ -43,7 +43,7 @@ using ModuleDependencyIDSet =
 class SwiftDependencyScanningService;
 
 namespace dependencies {
-class DependencyScanDiagnosticCollector;
+struct ScanQueryContext;
 
 using CompilerArgInstanceCacheMap =
     llvm::StringMap<std::tuple<std::unique_ptr<CompilerInstance>,
@@ -62,16 +62,15 @@ bool prescanDependencies(CompilerInstance &instance);
 /// Scans the dependencies of the main module of \c instance.
 llvm::ErrorOr<swiftscan_dependency_graph_t>
 performModuleScan(SwiftDependencyScanningService &service,
-                  CompilerInstance &instance,
                   ModuleDependenciesCache &cache,
-                  DependencyScanDiagnosticCollector *diagnostics = nullptr);
+                  ScanQueryContext &queryContext);
 
 /// Scans the main module of \c instance for all direct module imports
 llvm::ErrorOr<swiftscan_import_set_t>
 performModulePrescan(SwiftDependencyScanningService &service,
-                     CompilerInstance &instance,
                      ModuleDependenciesCache &cache,
-                     DependencyScanDiagnosticCollector *diagnostics = nullptr);
+                     ScanQueryContext &queryContext);
+
 
 namespace incremental {
 /// For the given module dependency graph captured in the 'cache',

include/swift/Frontend/SerializedDiagnosticConsumer.h

@@ -37,6 +37,15 @@ namespace swift {
     /// \returns A new diagnostic consumer that serializes diagnostics.
     std::unique_ptr<DiagnosticConsumer>
     createConsumer(llvm::StringRef outputPath, bool emitMacroExpansionFiles);
+
+    /// Create a thread-safe DiagnosticConsumer that serializes diagnostics to a file,
+    /// using Clang's serialized diagnostics format.
+    ///
+    /// \param outputPath the file path to write the diagnostics to.
+    ///
+    /// \returns A new diagnostic consumer that serializes diagnostics.
+    std::unique_ptr<DiagnosticConsumer>
+    createThreadSafeConsumer(llvm::StringRef outputPath, bool emitMacroExpansionFiles);
   }
 }
 

include/swift/Option/Options.td

@@ -2128,6 +2128,13 @@ def emit_module_serialize_diagnostics_path:
            "<path>">,
   MetaVarName<"<path>">;
 
+def dependency_scan_serialize_diagnostics_path:
+  Separate<["-"], "dependency-scan-serialize-diagnostics-path">,
+  Flags<[ArgumentIsPath, SupplementaryOutput, NewDriverOnlyOption]>,
+  HelpText<"Emit a serialized diagnostics file for the dependency scanning task to "
+           "<path>">,
+  MetaVarName<"<path>">;
+
 def emit_module_dependencies_path:
   Separate<["-"], "emit-module-dependencies-path">,
   Flags<[ArgumentIsPath, SupplementaryOutput, NewDriverOnlyOption]>,