diff --git a/include/swift-c/DependencyScan/DependencyScan.h b/include/swift-c/DependencyScan/DependencyScan.h index c65c431d070ed..06759ca79e3ba 100644 --- a/include/swift-c/DependencyScan/DependencyScan.h +++ b/include/swift-c/DependencyScan/DependencyScan.h @@ -61,6 +61,18 @@ typedef struct { size_t count; } swiftscan_dependency_set_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; + //=== Batch Scan Input Specification --------------------------------------===// /// Opaque container to a container of batch scan entry information. @@ -92,6 +104,12 @@ SWIFTSCAN_PUBLIC swiftscan_dependency_set_t * swiftscan_dependency_graph_get_dependencies( swiftscan_dependency_graph_t result); +// Return value disposed of together with the dependency_graph +// using `swiftscan_dependency_graph_dispose` +SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t * +swiftscan_dependency_graph_get_diagnostics( + swiftscan_dependency_graph_t result); + //=== Dependency Module Info Functions ------------------------------------===// SWIFTSCAN_PUBLIC swiftscan_string_ref_t @@ -277,6 +295,11 @@ swiftscan_batch_scan_entry_get_is_swift(swiftscan_batch_scan_entry_t entry); SWIFTSCAN_PUBLIC swiftscan_string_set_t * swiftscan_import_set_get_imports(swiftscan_import_set_t result); +// Return value disposed of together with the dependency_graph +// using `swiftscan_import_set_dispose` +SWIFTSCAN_PUBLIC swiftscan_diagnostic_set_t * +swiftscan_import_set_get_diagnostics(swiftscan_import_set_t result); + //=== Scanner Invocation Functions ----------------------------------------===// /// Create an \c swiftscan_scan_invocation_t instance. @@ -378,18 +401,6 @@ SWIFTSCAN_PUBLIC swiftscan_import_set_t swiftscan_import_set_create( //=== 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); diff --git a/include/swift/DependencyScan/DependencyScanImpl.h b/include/swift/DependencyScan/DependencyScanImpl.h index 42241950104ae..30f30e9128ca4 100644 --- a/include/swift/DependencyScan/DependencyScanImpl.h +++ b/include/swift/DependencyScan/DependencyScanImpl.h @@ -30,6 +30,9 @@ struct swiftscan_dependency_graph_s { /// The complete list of modules discovered swiftscan_dependency_set_t *dependencies; + + /// Diagnostics produced during this scan + swiftscan_diagnostic_set_t *diagnostics; }; struct swiftscan_dependency_info_s { @@ -192,6 +195,8 @@ struct swiftscan_batch_scan_entry_s { struct swiftscan_import_set_s { /// The complete list of imports discovered swiftscan_string_set_t *imports; + /// Diagnostics produced during this import scan + swiftscan_diagnostic_set_t *diagnostics; }; struct swiftscan_scan_invocation_s { diff --git a/include/swift/DependencyScan/DependencyScanningTool.h b/include/swift/DependencyScan/DependencyScanningTool.h index af8744b56044a..1709365ba46b9 100644 --- a/include/swift/DependencyScan/DependencyScanningTool.h +++ b/include/swift/DependencyScan/DependencyScanningTool.h @@ -24,28 +24,48 @@ namespace swift { namespace dependencies { class DependencyScanningTool; +class DependencyScanDiagnosticCollector; + +struct ScanQueryInstance { + std::unique_ptr ScanInstance; + std::unique_ptr ScanDiagnostics; +}; /// Diagnostic consumer that simply collects the diagnostics emitted so-far -class DependencyScannerDiagnosticCollectingConsumer : public DiagnosticConsumer { -public: - friend DependencyScanningTool; - DependencyScannerDiagnosticCollectingConsumer() {} - void reset() { Diagnostics.clear(); } +class DependencyScanDiagnosticCollector : public DiagnosticConsumer { private: struct ScannerDiagnosticInfo { std::string Message; llvm::SourceMgr::DiagKind Severity; }; - - void handleDiagnostic(SourceManager &SM, - const DiagnosticInfo &Info) override; - void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info); + + void handleDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) override; std::vector Diagnostics; - // FIXME: For now, we isolate access to shared state of this object - // but we really should make sure that it doesn't get shared. - llvm::sys::SmartMutex ScanningDiagnosticConsumerStateLock; + +protected: + virtual void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info); + +public: + friend DependencyScanningTool; + DependencyScanDiagnosticCollector() {} + void reset() { Diagnostics.clear(); } + const std::vector &getDiagnostics() const { + return Diagnostics; + } }; +/// Locking variant of the above diagnostic collector that guards accesses to +/// its state with a lock. +class LockingDependencyScanDiagnosticCollector + : public DependencyScanDiagnosticCollector { +private: + void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) override; + llvm::sys::SmartMutex ScanningDiagnosticConsumerStateLock; + +public: + friend DependencyScanningTool; + LockingDependencyScanDiagnosticCollector() {} +}; /// Given a set of arguments to a print-target-info frontend tool query, produce the /// JSON target info. @@ -93,19 +113,19 @@ class DependencyScanningTool { /// Discard the tool's current `SharedCache` and start anew. void resetCache(); /// Query diagnostics consumed so far. - std::vector getDiagnostics(); + std::vector getDiagnostics(); /// Discared the collection of diagnostics encountered so far. void resetDiagnostics(); /// Using the specified invocation command, instantiate a CompilerInstance /// that will be used for this scan. - llvm::ErrorOr> + llvm::ErrorOr initCompilerInstanceForScan(ArrayRef Command); private: /// Using the specified invocation command, initialize the scanner instance /// for this scan. Returns the `CompilerInstance` that will be used. - llvm::ErrorOr> + llvm::ErrorOr initScannerForAction(ArrayRef Command); /// Shared cache of module dependencies, re-used by individual full-scan queries @@ -120,7 +140,7 @@ class DependencyScanningTool { llvm::sys::SmartMutex DependencyScanningToolStateLock; /// A shared consumer that accumulates encountered diagnostics. - DependencyScannerDiagnosticCollectingConsumer CDC; + LockingDependencyScanDiagnosticCollector CDC; llvm::BumpPtrAllocator Alloc; llvm::StringSaver Saver; }; diff --git a/include/swift/DependencyScan/ScanDependencies.h b/include/swift/DependencyScan/ScanDependencies.h index d8d5b37bfe2ff..e145c544d5281 100644 --- a/include/swift/DependencyScan/ScanDependencies.h +++ b/include/swift/DependencyScan/ScanDependencies.h @@ -30,6 +30,7 @@ class ModuleDependenciesCache; class SwiftDependencyScanningService; namespace dependencies { +class DependencyScanDiagnosticCollector; using CompilerArgInstanceCacheMap = llvm::StringMap, @@ -59,16 +60,19 @@ bool batchScanDependencies(CompilerInstance &instance, /// Scans the dependencies of the main module of \c instance. llvm::ErrorOr performModuleScan(CompilerInstance &instance, + DependencyScanDiagnosticCollector *diagnostics, ModuleDependenciesCache &cache); /// Scans the main module of \c instance for all direct module imports llvm::ErrorOr performModulePrescan(CompilerInstance &instance, + DependencyScanDiagnosticCollector *diagnostics, ModuleDependenciesCache &cache); /// Batch scan the dependencies for modules specified in \c batchInputFile. std::vector> performBatchModuleScan(CompilerInstance &invocationInstance, + DependencyScanDiagnosticCollector *diagnostics, ModuleDependenciesCache &invocationCache, CompilerArgInstanceCacheMap *versionedPCMInstanceCache, llvm::StringSaver &saver, diff --git a/lib/DependencyScan/DependencyScanningTool.cpp b/lib/DependencyScan/DependencyScanningTool.cpp index 363966b7a05aa..04f6fbce34f52 100644 --- a/lib/DependencyScan/DependencyScanningTool.cpp +++ b/lib/DependencyScan/DependencyScanningTool.cpp @@ -68,7 +68,7 @@ llvm::ErrorOr getTargetInfo(ArrayRef Comma return c_string_utils::create_clone(ResultStr.c_str()); } -void DependencyScannerDiagnosticCollectingConsumer::handleDiagnostic(SourceManager &SM, +void DependencyScanDiagnosticCollector::handleDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) { addDiagnostic(SM, Info); for (auto ChildInfo : Info.ChildDiagnosticInfo) { @@ -76,8 +76,8 @@ void DependencyScannerDiagnosticCollectingConsumer::handleDiagnostic(SourceManag } } -void DependencyScannerDiagnosticCollectingConsumer::addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) { - llvm::sys::SmartScopedLock Lock(ScanningDiagnosticConsumerStateLock); +void DependencyScanDiagnosticCollector::addDiagnostic( + SourceManager &SM, const DiagnosticInfo &Info) { // Determine what kind of diagnostic we're emitting. llvm::SourceMgr::DiagKind SMKind; switch (Info.Kind) { @@ -115,6 +115,12 @@ void DependencyScannerDiagnosticCollectingConsumer::addDiagnostic(SourceManager Diagnostics.push_back(ScannerDiagnosticInfo{Msg.getMessage().str(), SMKind}); } +void LockingDependencyScanDiagnosticCollector::addDiagnostic( + SourceManager &SM, const DiagnosticInfo &Info) { + llvm::sys::SmartScopedLock Lock(ScanningDiagnosticConsumerStateLock); + DependencyScanDiagnosticCollector::addDiagnostic(SM, Info); +} + DependencyScanningTool::DependencyScanningTool() : ScanningService(std::make_unique()), VersionedPCMInstanceCacheCache( @@ -126,18 +132,20 @@ DependencyScanningTool::getDependencies( ArrayRef Command, const llvm::StringSet<> &PlaceholderModules) { // The primary instance used to scan the query Swift source-code - auto InstanceOrErr = initScannerForAction(Command); - if (std::error_code EC = InstanceOrErr.getError()) + auto QueryContextOrErr = initScannerForAction(Command); + if (std::error_code EC = QueryContextOrErr.getError()) return EC; - auto Instance = std::move(*InstanceOrErr); + auto QueryContext = std::move(*QueryContextOrErr); // Local scan cache instance, wrapping the shared global cache. ModuleDependenciesCache cache( - *ScanningService, Instance->getMainModule()->getNameStr().str(), - Instance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, - Instance->getInvocation().getModuleScanningHash()); + *ScanningService, QueryContext.ScanInstance->getMainModule()->getNameStr().str(), + QueryContext.ScanInstance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, + QueryContext.ScanInstance->getInvocation().getModuleScanningHash()); // Execute the scanning action, retrieving the in-memory result - auto DependenciesOrErr = performModuleScan(*Instance.get(), cache); + auto DependenciesOrErr = performModuleScan(*QueryContext.ScanInstance.get(), + QueryContext.ScanDiagnostics.get(), + cache); if (DependenciesOrErr.getError()) return std::make_error_code(std::errc::not_supported); auto Dependencies = std::move(*DependenciesOrErr); @@ -148,17 +156,19 @@ DependencyScanningTool::getDependencies( llvm::ErrorOr DependencyScanningTool::getImports(ArrayRef Command) { // The primary instance used to scan the query Swift source-code - auto InstanceOrErr = initScannerForAction(Command); - if (std::error_code EC = InstanceOrErr.getError()) + auto QueryContextOrErr = initScannerForAction(Command); + if (std::error_code EC = QueryContextOrErr.getError()) return EC; - auto Instance = std::move(*InstanceOrErr); + auto QueryContext = std::move(*QueryContextOrErr); // Local scan cache instance, wrapping the shared global cache. ModuleDependenciesCache cache( - *ScanningService, Instance->getMainModule()->getNameStr().str(), - Instance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, - Instance->getInvocation().getModuleScanningHash()); - auto DependenciesOrErr = performModulePrescan(*Instance.get(), cache); + *ScanningService, QueryContext.ScanInstance->getMainModule()->getNameStr().str(), + QueryContext.ScanInstance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, + QueryContext.ScanInstance->getInvocation().getModuleScanningHash()); + auto DependenciesOrErr = performModulePrescan(*QueryContext.ScanInstance.get(), + QueryContext.ScanDiagnostics.get(), + cache); if (DependenciesOrErr.getError()) return std::make_error_code(std::errc::not_supported); auto Dependencies = std::move(*DependenciesOrErr); @@ -172,19 +182,20 @@ DependencyScanningTool::getDependencies( const std::vector &BatchInput, const llvm::StringSet<> &PlaceholderModules) { // The primary instance used to scan Swift modules - auto InstanceOrErr = initScannerForAction(Command); - if (std::error_code EC = InstanceOrErr.getError()) + auto QueryContextOrErr = initScannerForAction(Command); + if (std::error_code EC = QueryContextOrErr.getError()) return std::vector>( BatchInput.size(), std::make_error_code(std::errc::invalid_argument)); - auto Instance = std::move(*InstanceOrErr); + auto QueryContext = std::move(*QueryContextOrErr); // Local scan cache instance, wrapping the shared global cache. ModuleDependenciesCache cache( - *ScanningService, Instance->getMainModule()->getNameStr().str(), - Instance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, - Instance->getInvocation().getModuleScanningHash()); + *ScanningService, QueryContext.ScanInstance->getMainModule()->getNameStr().str(), + QueryContext.ScanInstance->getInvocation().getFrontendOptions().ExplicitModulesOutputPath, + QueryContext.ScanInstance->getInvocation().getModuleScanningHash()); auto BatchScanResults = performBatchModuleScan( - *Instance.get(), cache, VersionedPCMInstanceCacheCache.get(), + *QueryContext.ScanInstance.get(), QueryContext.ScanDiagnostics.get(), + cache, VersionedPCMInstanceCacheCache.get(), Saver, BatchInput); return BatchScanResults; @@ -221,7 +232,7 @@ void DependencyScanningTool::resetCache() { } std::vector< - DependencyScannerDiagnosticCollectingConsumer::ScannerDiagnosticInfo> + DependencyScanDiagnosticCollector::ScannerDiagnosticInfo> DependencyScanningTool::getDiagnostics() { llvm::sys::SmartScopedLock Lock(DependencyScanningToolStateLock); return CDC.Diagnostics; @@ -232,25 +243,27 @@ void DependencyScanningTool::resetDiagnostics() { CDC.reset(); } -llvm::ErrorOr> +llvm::ErrorOr DependencyScanningTool::initScannerForAction( ArrayRef Command) { // The remainder of this method operates on shared state in the // scanning service and global LLVM state with: // llvm::cl::ResetAllOptionOccurrences llvm::sys::SmartScopedLock Lock(DependencyScanningToolStateLock); - auto instanceOrErr = initCompilerInstanceForScan(Command); - if (instanceOrErr.getError()) - return instanceOrErr; - return instanceOrErr; + return initCompilerInstanceForScan(Command); } -llvm::ErrorOr> +llvm::ErrorOr DependencyScanningTool::initCompilerInstanceForScan( ArrayRef CommandArgs) { // State unique to an individual scan auto Instance = std::make_unique(); + auto ScanDiagnosticConsumer = std::make_unique(); + + // FIXME: The shared CDC must be deprecated once all clients have switched + // to using per-scan diagnostic output embedded in the `swiftscan_dependency_graph_s` Instance->addDiagnosticConsumer(&CDC); + Instance->addDiagnosticConsumer(ScanDiagnosticConsumer.get()); // Basic error checking on the arguments if (CommandArgs.empty()) { @@ -300,7 +313,8 @@ DependencyScanningTool::initCompilerInstanceForScan( (void)Instance->getMainModule(); - return Instance; + return ScanQueryInstance{std::move(Instance), + std::move(ScanDiagnosticConsumer)}; } } // namespace dependencies diff --git a/lib/DependencyScan/ScanDependencies.cpp b/lib/DependencyScan/ScanDependencies.cpp index 87719dd9b9bab..542a053cb54e6 100644 --- a/lib/DependencyScan/ScanDependencies.cpp +++ b/lib/DependencyScan/ScanDependencies.cpp @@ -29,6 +29,7 @@ #include "swift/Basic/STLExtras.h" #include "swift/ClangImporter/ClangImporter.h" #include "swift/DependencyScan/DependencyScanImpl.h" +#include "swift/DependencyScan/DependencyScanningTool.h" #include "swift/DependencyScan/ModuleDependencyScanner.h" #include "swift/DependencyScan/ScanDependencies.h" #include "swift/DependencyScan/SerializedModuleDependencyCacheFormat.h" @@ -1070,8 +1071,42 @@ static void bridgeDependencyIDs(const ArrayRef dependencies, } } +static swiftscan_diagnostic_set_t *mapCollectedDiagnosticsForOutput( + const DependencyScanDiagnosticCollector *diagnosticCollector) { + auto collectedDiagnostics = diagnosticCollector->getDiagnostics(); + auto numDiagnostics = collectedDiagnostics.size(); + swiftscan_diagnostic_set_t *diagnosticOutput = new swiftscan_diagnostic_set_t; + diagnosticOutput->count = numDiagnostics; + diagnosticOutput->diagnostics = + new swiftscan_diagnostic_info_t[numDiagnostics]; + for (size_t i = 0; i < numDiagnostics; ++i) { + const auto &Diagnostic = collectedDiagnostics[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; + } + diagnosticOutput->diagnostics[i] = diagnosticInfo; + } + return diagnosticOutput; +} + static swiftscan_dependency_graph_t generateFullDependencyGraph(const CompilerInstance &instance, + const DependencyScanDiagnosticCollector *diagnosticCollector, const ModuleDependenciesCache &cache, const ArrayRef allModules) { if (allModules.empty()) { @@ -1253,6 +1288,10 @@ generateFullDependencyGraph(const CompilerInstance &instance, swiftscan_dependency_graph_t result = new swiftscan_dependency_graph_s; result->main_module_name = create_clone(mainModuleName.c_str()); result->dependencies = dependencySet; + result->diagnostics = + diagnosticCollector + ? mapCollectedDiagnosticsForOutput(diagnosticCollector) + : nullptr; return result; } @@ -1668,7 +1707,7 @@ bool swift::dependencies::scanDependencies(CompilerInstance &instance) { // Execute scan llvm::ErrorOr dependenciesOrErr = - performModuleScan(instance, cache); + performModuleScan(instance, nullptr, cache); // Serialize the dependency cache if -serialize-dependency-scan-cache // is specified @@ -1704,7 +1743,7 @@ bool swift::dependencies::prescanDependencies(CompilerInstance &instance) { instance.getInvocation().getModuleScanningHash()); // Execute import prescan, and write JSON output to the output stream - auto importSetOrErr = performModulePrescan(instance, cache); + auto importSetOrErr = performModulePrescan(instance, nullptr, cache); if (importSetOrErr.getError()) return true; auto importSet = std::move(*importSetOrErr); @@ -1744,7 +1783,8 @@ bool swift::dependencies::batchScanDependencies( return true; auto batchScanResults = performBatchModuleScan( - instance, cache, /*versionedPCMInstanceCache*/ nullptr, saver, + instance, /*DependencyScanDiagnosticCollector*/ nullptr, + cache, /*versionedPCMInstanceCache*/ nullptr, saver, *batchInput); // Write the result JSON to the specified output path, for each entry @@ -1848,6 +1888,7 @@ updateDependencyTracker(CompilerInstance &instance, llvm::ErrorOr swift::dependencies::performModuleScan(CompilerInstance &instance, + DependencyScanDiagnosticCollector *diagnosticCollector, ModuleDependenciesCache &cache) { auto scanner = ModuleDependencyScanner( cache.getScanService(), instance.getInvocation(), @@ -1893,12 +1934,13 @@ swift::dependencies::performModuleScan(CompilerInstance &instance, topologicallySortedModuleList); updateDependencyTracker(instance, cache, allModules); - return generateFullDependencyGraph(instance, cache, + return generateFullDependencyGraph(instance, diagnosticCollector, cache, topologicallySortedModuleList); } llvm::ErrorOr swift::dependencies::performModulePrescan(CompilerInstance &instance, + DependencyScanDiagnosticCollector *diagnosticCollector, ModuleDependenciesCache &cache) { // Setup the scanner auto scanner = ModuleDependencyScanner( @@ -1913,12 +1955,17 @@ swift::dependencies::performModulePrescan(CompilerInstance &instance, return mainDependencies.getError(); auto *importSet = new swiftscan_import_set_s; importSet->imports = create_set(mainDependencies->getModuleImports()); + importSet->diagnostics = + diagnosticCollector + ? mapCollectedDiagnosticsForOutput(diagnosticCollector) + : nullptr; return importSet; } std::vector> swift::dependencies::performBatchModuleScan( CompilerInstance &invocationInstance, + DependencyScanDiagnosticCollector *diagnosticCollector, ModuleDependenciesCache &invocationCache, CompilerArgInstanceCacheMap *versionedPCMInstanceCache, llvm::StringSaver &saver, const std::vector &batchInput) { @@ -1929,7 +1976,8 @@ swift::dependencies::performBatchModuleScan( forEachBatchEntry( invocationInstance, invocationCache, versionedPCMInstanceCache, saver, batchInput, - [&batchScanResult](BatchScanInput entry, CompilerInstance &instance, + [&batchScanResult, &diagnosticCollector](BatchScanInput entry, + CompilerInstance &instance, ModuleDependenciesCache &cache) { auto scanner = ModuleDependencyScanner( cache.getScanService(), instance.getInvocation(), @@ -1961,7 +2009,10 @@ swift::dependencies::performBatchModuleScan( : ModuleDependencyKind::SwiftInterface}; auto allDependencies = scanner.getModuleDependencies(moduleID, cache); batchScanResult.push_back( - generateFullDependencyGraph(instance, cache, allDependencies)); + generateFullDependencyGraph(instance, diagnosticCollector, + cache, allDependencies)); + if (diagnosticCollector) + diagnosticCollector->reset(); }); return batchScanResult; diff --git a/tools/libSwiftScan/libSwiftScan.cpp b/tools/libSwiftScan/libSwiftScan.cpp index 04f492f4f81d2..c194b86f637f1 100644 --- a/tools/libSwiftScan/libSwiftScan.cpp +++ b/tools/libSwiftScan/libSwiftScan.cpp @@ -221,6 +221,11 @@ swiftscan_dependency_set_t *swiftscan_dependency_graph_get_dependencies( return result->dependencies; } +swiftscan_diagnostic_set_t *swiftscan_dependency_graph_get_diagnostics( + swiftscan_dependency_graph_t result) { + return result->diagnostics; +} + //=== Module Dependency Info query APIs -----------------------------------===// swiftscan_string_ref_t @@ -472,6 +477,11 @@ swiftscan_import_set_get_imports(swiftscan_import_set_t result) { return result->imports; } +swiftscan_diagnostic_set_t * +swiftscan_import_set_get_diagnostics(swiftscan_import_set_t result) { + return result->diagnostics; +} + //=== Scanner Invocation Functions ----------------------------------------===// swiftscan_scan_invocation_t swiftscan_scan_invocation_create() { @@ -521,11 +531,13 @@ void swiftscan_string_set_dispose(swiftscan_string_set_t *set) { void swiftscan_dependency_graph_dispose(swiftscan_dependency_graph_t result) { swiftscan_string_dispose(result->main_module_name); swiftscan_dependency_set_dispose(result->dependencies); + swiftscan_diagnostics_set_dispose(result->diagnostics); delete result; } void swiftscan_import_set_dispose(swiftscan_import_set_t result) { swiftscan_string_set_dispose(result->imports); + swiftscan_diagnostics_set_dispose(result->diagnostics); delete result; } diff --git a/tools/libSwiftScan/libSwiftScan.exports b/tools/libSwiftScan/libSwiftScan.exports index 89bc2dbfaa8d5..f79974514a9a9 100644 --- a/tools/libSwiftScan/libSwiftScan.exports +++ b/tools/libSwiftScan/libSwiftScan.exports @@ -1,5 +1,6 @@ swiftscan_dependency_graph_get_main_module_name swiftscan_dependency_graph_get_dependencies +swiftscan_dependency_graph_get_diagnostics swiftscan_module_info_get_module_name swiftscan_module_info_get_module_path swiftscan_module_info_get_source_files @@ -43,6 +44,7 @@ swiftscan_batch_scan_entry_get_module_name swiftscan_batch_scan_entry_get_arguments swiftscan_batch_scan_entry_get_is_swift swiftscan_import_set_get_imports +swiftscan_import_set_get_diagnostics swiftscan_scan_invocation_set_working_directory swiftscan_scan_invocation_set_argv swiftscan_scan_invocation_get_working_directory diff --git a/unittests/DependencyScan/ModuleDeps.cpp b/unittests/DependencyScan/ModuleDeps.cpp index ef67089ed4d8b..be311eef96a7c 100644 --- a/unittests/DependencyScan/ModuleDeps.cpp +++ b/unittests/DependencyScan/ModuleDeps.cpp @@ -246,6 +246,6 @@ public func overlayFuncA() { }\n")); auto instanceA = ScannerTool.initCompilerInstanceForScan(CommandA); auto instanceB = ScannerTool.initCompilerInstanceForScan(CommandB); // Ensure that scans that only differ in module name have distinct scanning context hashes - ASSERT_NE(instanceA->get()->getInvocation().getModuleScanningHash(), - instanceB->get()->getInvocation().getModuleScanningHash()); + ASSERT_NE(instanceA->ScanInstance.get()->getInvocation().getModuleScanningHash(), + instanceB->ScanInstance.get()->getInvocation().getModuleScanningHash()); }