Merge pull request #60999 from artemcm/LibSwiftScanDiagnostics

artemcm · web-flow · commit 3211b9357ca1 · 2022-09-12T10:38:19.000-07:00
[Dependency Scanner] Add API to query emitted diagnostics during a scan
diff --git a/include/swift-c/DependencyScan/DependencyScan.h b/include/swift-c/DependencyScan/DependencyScan.h
@@ -25,7 +25,7 @@
 /// SWIFTSCAN_VERSION_MINOR should increase when there are API additions.
 /// SWIFTSCAN_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
 #define SWIFTSCAN_VERSION_MAJOR 0
-#define SWIFTSCAN_VERSION_MINOR 2
+#define SWIFTSCAN_VERSION_MINOR 3
 
 SWIFTSCAN_BEGIN_DECLS
 
@@ -52,6 +52,9 @@ typedef struct swiftscan_dependency_graph_s *swiftscan_dependency_graph_t;
 /// Opaque container to contain the result of a dependency prescan.
 typedef struct swiftscan_import_set_s *swiftscan_import_set_t;
 
+/// Opaque container to contain the info of a diagnostics emitted by the scanner.
+typedef struct swiftscan_diagnostic_info_s *swiftscan_diagnostic_info_t;
+
 /// Full Dependency Graph (Result)
 typedef struct {
   swiftscan_dependency_info_t *modules;
@@ -329,6 +332,37 @@ swiftscan_batch_scan_result_create(swiftscan_scanner_t scanner,
 SWIFTSCAN_PUBLIC swiftscan_import_set_t swiftscan_import_set_create(
     swiftscan_scanner_t scanner, swiftscan_scan_invocation_t invocation);
 
+
+//=== Scanner Diagnostics -------------------------------------------------===//
+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;
+
+/// For the specified \c scanner instance, query all insofar emitted diagnostics
+SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t*
+swiftscan_scanner_diagnostics_query(swiftscan_scanner_t scanner);
+
+/// For the specified \c scanner instance, reset its diagnostic state
+SWIFTSCAN_PUBLIC void
+swiftscan_scanner_diagnostics_reset(swiftscan_scanner_t scanner);
+
+SWIFTSCAN_PUBLIC swiftscan_string_ref_t
+swiftscan_diagnostic_get_message(swiftscan_diagnostic_info_t diagnostic);
+
+SWIFTSCAN_PUBLIC swiftscan_diagnostic_severity_t
+swiftscan_diagnostic_get_severity(swiftscan_diagnostic_info_t diagnostic);
+
+SWIFTSCAN_PUBLIC void
+swiftscan_diagnostics_set_dispose(swiftscan_diagnostic_set_t* diagnostics);
+
 //=== Scanner Cache Operations --------------------------------------------===//
 // The following operations expose an implementation detail of the dependency
 // scanner: its module dependencies cache. This is done in order
diff --git a/include/swift/DependencyScan/DependencyScanImpl.h b/include/swift/DependencyScan/DependencyScanImpl.h
@@ -160,4 +160,10 @@ struct swiftscan_scan_invocation_s {
   swiftscan_string_set_t *argv;
 };
 
+struct swiftscan_diagnostic_info_s {
+  swiftscan_string_ref_t message;
+  swiftscan_diagnostic_severity_t severity;
+  // TODO: SourceLoc
+};
+
 #endif // SWIFT_C_DEPENDENCY_SCAN_IMPL_H
diff --git a/include/swift/DependencyScan/DependencyScanningTool.h b/include/swift/DependencyScan/DependencyScanningTool.h
@@ -23,6 +23,28 @@
 
 namespace swift {
 namespace dependencies {
+class DependencyScanningTool;
+
+/// Diagnostic consumer that simply collects the diagnostics emitted so-far
+class DependencyScannerDiagnosticCollectingConsumer : public DiagnosticConsumer {
+public:
+  friend DependencyScanningTool;
+  DependencyScannerDiagnosticCollectingConsumer() {}
+  void reset() { Diagnostics.clear(); }
+private:
+  struct ScannerDiagnosticInfo {
+    std::string Message;
+    llvm::SourceMgr::DiagKind Severity;
+  };
+  
+  void handleDiagnostic(SourceManager &SM,
+                        const DiagnosticInfo &Info) override;
+  ScannerDiagnosticInfo convertDiagnosticInfo(SourceManager &SM,
+                                              const DiagnosticInfo &Info);
+  void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info);
+  std::vector<ScannerDiagnosticInfo> Diagnostics;
+};
+
 
 /// Given a set of arguments to a print-target-info frontend tool query, produce the
 /// JSON target info.
@@ -68,6 +90,10 @@ class DependencyScanningTool {
   bool loadCache(llvm::StringRef path);
   /// Discard the tool's current `SharedCache` and start anew.
   void resetCache();
+  
+  const std::vector<DependencyScannerDiagnosticCollectingConsumer::ScannerDiagnosticInfo>& getDiagnostics() const { return CDC.Diagnostics; }
+  /// Discared the collection of diagnostics encountered so far.
+  void resetDiagnostics();
 
 private:
   /// Using the specified invocation command, initialize the scanner instance
@@ -88,8 +114,8 @@ class DependencyScanningTool {
   /// command-line options specified in the batch scan input entry.
   std::unique_ptr<CompilerArgInstanceCacheMap> VersionedPCMInstanceCacheCache;
 
-  /// A shared consumer that, for now, just prints the encountered diagnostics.
-  PrintingDiagnosticConsumer PDC;
+  /// A shared consumer that accumulates encountered diagnostics.
+  DependencyScannerDiagnosticCollectingConsumer CDC;
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver Saver;
 };
diff --git a/lib/DependencyScan/DependencyScanningTool.cpp b/lib/DependencyScan/DependencyScanningTool.cpp
@@ -56,11 +56,58 @@ llvm::ErrorOr<swiftscan_string_ref_t> getTargetInfo(ArrayRef<const char *> Comma
   return c_string_utils::create_clone(ResultStr.c_str());
 }
 
+void DependencyScannerDiagnosticCollectingConsumer::handleDiagnostic(SourceManager &SM,
+                      const DiagnosticInfo &Info) {
+  addDiagnostic(SM, Info);
+  for (auto ChildInfo : Info.ChildDiagnosticInfo) {
+    addDiagnostic(SM, *ChildInfo);
+  }
+}
+
+void DependencyScannerDiagnosticCollectingConsumer::addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) {
+  // Determine what kind of diagnostic we're emitting.
+  llvm::SourceMgr::DiagKind SMKind;
+  switch (Info.Kind) {
+  case DiagnosticKind::Error:
+    SMKind = llvm::SourceMgr::DK_Error;
+    break;
+  case DiagnosticKind::Warning:
+    SMKind = llvm::SourceMgr::DK_Warning;
+    break;
+  case DiagnosticKind::Note:
+    SMKind = llvm::SourceMgr::DK_Note;
+    break;
+  case DiagnosticKind::Remark:
+    SMKind = llvm::SourceMgr::DK_Remark;
+    break;
+  }
+  // Translate ranges.
+  SmallVector<llvm::SMRange, 2> Ranges;
+  for (auto R : Info.Ranges)
+    Ranges.push_back(getRawRange(SM, R));
+  // Translate fix-its.
+  SmallVector<llvm::SMFixIt, 2> FixIts;
+  for (DiagnosticInfo::FixIt F : Info.FixIts)
+    FixIts.push_back(getRawFixIt(SM, F));
+
+  std::string ResultingMessage;
+  llvm::raw_string_ostream Stream(ResultingMessage);
+  const llvm::SourceMgr &rawSM = SM.getLLVMSourceMgr();
+  
+  // Actually substitute the diagnostic arguments into the diagnostic text.
+  llvm::SmallString<256> Text;
+  llvm::raw_svector_ostream Out(Text);
+  DiagnosticEngine::formatDiagnosticText(Out, Info.FormatString,
+                                         Info.FormatArgs);
+  auto Msg = SM.GetMessage(Info.Loc, SMKind, Text, Ranges, FixIts);
+  Diagnostics.push_back(ScannerDiagnosticInfo{Msg.getMessage().str(), SMKind});
+}
+
 DependencyScanningTool::DependencyScanningTool()
     : SharedCache(std::make_unique<GlobalModuleDependenciesCache>()),
       VersionedPCMInstanceCacheCache(
           std::make_unique<CompilerArgInstanceCacheMap>()),
-      PDC(), Alloc(), Saver(Alloc) {}
+      CDC(), Alloc(), Saver(Alloc) {}
 
 llvm::ErrorOr<swiftscan_dependency_graph_t>
 DependencyScanningTool::getDependencies(
@@ -126,15 +173,15 @@ DependencyScanningTool::getDependencies(
 void DependencyScanningTool::serializeCache(llvm::StringRef path) {
   SourceManager SM;
   DiagnosticEngine Diags(SM);
-  Diags.addConsumer(PDC);
+  Diags.addConsumer(CDC);
   module_dependency_cache_serialization::writeInterModuleDependenciesCache(
       Diags, path, *SharedCache);
 }
 
 bool DependencyScanningTool::loadCache(llvm::StringRef path) {
   SourceManager SM;
   DiagnosticEngine Diags(SM);
-  Diags.addConsumer(PDC);
+  Diags.addConsumer(CDC);
   SharedCache = std::make_unique<GlobalModuleDependenciesCache>();
   bool readFailed =
       module_dependency_cache_serialization::readInterModuleDependenciesCache(
@@ -149,6 +196,10 @@ void DependencyScanningTool::resetCache() {
   SharedCache.reset(new GlobalModuleDependenciesCache());
 }
 
+void DependencyScanningTool::resetDiagnostics() {
+  CDC.reset();
+}
+
 llvm::ErrorOr<std::unique_ptr<CompilerInstance>>
 DependencyScanningTool::initScannerForAction(
     ArrayRef<const char *> Command) {
@@ -165,7 +216,7 @@ DependencyScanningTool::initCompilerInstanceForScan(
     ArrayRef<const char *> CommandArgs) {
   // State unique to an individual scan
   auto Instance = std::make_unique<CompilerInstance>();
-  Instance->addDiagnosticConsumer(&PDC);
+  Instance->addDiagnosticConsumer(&CDC);
 
   // Basic error checking on the arguments
   if (CommandArgs.empty()) {
diff --git a/tools/libSwiftScan/libSwiftScan.cpp b/tools/libSwiftScan/libSwiftScan.cpp
@@ -534,6 +534,70 @@ swiftscan_compiler_supported_features_query() {
   return swift::c_string_utils::create_set(allFeatures);
 }
 
+//=== Scanner Diagnostics -------------------------------------------------===//
+swiftscan_diagnostic_set_t*
+swiftscan_scanner_diagnostics_query(swiftscan_scanner_t scanner) {
+  DependencyScanningTool *ScanningTool = unwrap(scanner);
+  auto NumDiagnostics = ScanningTool->getDiagnostics().size();
+  
+  swiftscan_diagnostic_set_t *Result = new swiftscan_diagnostic_set_t;
+  Result->count = NumDiagnostics;
+  Result->diagnostics = new swiftscan_diagnostic_info_t[NumDiagnostics];
+  
+  for (size_t i = 0; i < NumDiagnostics; ++i) {
+    const auto &Diagnostic = ScanningTool->getDiagnostics()[i];
+    swiftscan_diagnostic_info_s *DiagnosticInfo = new swiftscan_diagnostic_info_s;
+    DiagnosticInfo->message = swift::c_string_utils::create_clone(Diagnostic.Message.c_str());
+    switch (Diagnostic.Severity) {
+    case llvm::SourceMgr::DK_Error:
+      DiagnosticInfo->severity = SWIFTSCAN_DIAGNOSTIC_SEVERITY_ERROR;
+      break;
+    case llvm::SourceMgr::DK_Warning:
+      DiagnosticInfo->severity = SWIFTSCAN_DIAGNOSTIC_SEVERITY_WARNING;
+      break;
+    case llvm::SourceMgr::DK_Note:
+      DiagnosticInfo->severity = SWIFTSCAN_DIAGNOSTIC_SEVERITY_NOTE;
+      break;
+    case llvm::SourceMgr::DK_Remark:
+      DiagnosticInfo->severity = SWIFTSCAN_DIAGNOSTIC_SEVERITY_REMARK;
+      break;
+    }
+    Result->diagnostics[i] = DiagnosticInfo;
+  }
+
+  return Result;
+}
+
+void
+swiftscan_scanner_diagnostics_reset(swiftscan_scanner_t scanner) {
+  DependencyScanningTool *ScanningTool = unwrap(scanner);
+  ScanningTool->resetDiagnostics();
+}
+
+swiftscan_string_ref_t
+swiftscan_diagnostic_get_message(swiftscan_diagnostic_info_t diagnostic) {
+  return diagnostic->message;
+}
+
+swiftscan_diagnostic_severity_t
+swiftscan_diagnostic_get_severity(swiftscan_diagnostic_info_t diagnostic) {
+  return diagnostic->severity;
+}
+
+void swiftscan_diagnostic_dispose(swiftscan_diagnostic_info_t diagnostic) {
+  swiftscan_string_dispose(diagnostic->message);
+  delete diagnostic;
+}
+
+void
+swiftscan_diagnostics_set_dispose(swiftscan_diagnostic_set_t* diagnostics){
+  for (size_t i = 0; i < diagnostics->count; ++i) {
+    swiftscan_diagnostic_dispose(diagnostics->diagnostics[i]);
+  }
+  delete[] diagnostics->diagnostics;
+  delete diagnostics;
+}
+
 //=== Experimental Compiler Invocation Functions ------------------------===//
 
 int invoke_swift_compiler(int argc, const char **argv) {
diff --git a/tools/libSwiftScan/libSwiftScan.exports b/tools/libSwiftScan/libSwiftScan.exports
@@ -59,4 +59,9 @@ swiftscan_compiler_target_info_query
 swiftscan_scanner_cache_serialize
 swiftscan_scanner_cache_load
 swiftscan_scanner_cache_reset
+swiftscan_scanner_diagnostics_query
+swiftscan_scanner_diagnostics_reset
+swiftscan_diagnostic_get_message
+swiftscan_diagnostic_get_severity
+swiftscan_diagnostics_set_dispose
 invoke_swift_compiler
