From 44d8bb01ddb6816436210c54638b81d8608a0d72 Mon Sep 17 00:00:00 2001 From: Qiongsi Wu Date: Wed, 5 Mar 2025 14:53:40 -0800 Subject: [PATCH 1/4] Remove dead code. --- .../DependencyScan/ModuleDependencyScanner.h | 7 --- .../ModuleDependencyScanner.cpp | 47 ------------------- 2 files changed, 54 deletions(-) diff --git a/include/swift/DependencyScan/ModuleDependencyScanner.h b/include/swift/DependencyScan/ModuleDependencyScanner.h index ed96333a7a402..067463b9c4ab4 100644 --- a/include/swift/DependencyScan/ModuleDependencyScanner.h +++ b/include/swift/DependencyScan/ModuleDependencyScanner.h @@ -91,13 +91,6 @@ class ModuleDependencyScanner { performDependencyScan(ModuleDependencyID rootModuleID, ModuleDependenciesCache &cache); - /// Query the module dependency info for the Clang module with the given name. - /// Explicit by-name lookups are useful for batch mode scanning. - std::optional - getNamedClangModuleDependencyInfo(StringRef moduleName, - ModuleDependenciesCache &cache, - ModuleDependencyIDSetVector &discoveredClangModules); - /// Query the module dependency info for the Swift module with the given name. /// Explicit by-name lookups are useful for batch mode scanning. std::optional diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp index 24d472cbb9b73..b5914f4b2660f 100644 --- a/lib/DependencyScan/ModuleDependencyScanner.cpp +++ b/lib/DependencyScan/ModuleDependencyScanner.cpp @@ -486,53 +486,6 @@ ModuleDependencyScanner::getMainModuleDependencyInfo(ModuleDecl *mainModule) { return mainDependencies; } -/// Retrieve the module dependencies for the Clang module with the given name. -std::optional -ModuleDependencyScanner::getNamedClangModuleDependencyInfo( - StringRef moduleName, ModuleDependenciesCache &cache, - ModuleDependencyIDSetVector &discoveredClangModules) { - // Check whether we've cached this result. - auto moduleID = ModuleDependencyID{moduleName.str(), - ModuleDependencyKind::Clang}; - if (auto found = cache.findDependency(moduleID)) { - discoveredClangModules.insert(moduleID); - auto directClangDeps = cache.getImportedClangDependencies(moduleID); - ModuleDependencyIDSetVector reachableClangModules; - reachableClangModules.insert(directClangDeps.begin(), - directClangDeps.end()); - for (unsigned currentModuleIdx = 0; - currentModuleIdx < reachableClangModules.size(); - ++currentModuleIdx) { - auto moduleID = reachableClangModules[currentModuleIdx]; - auto dependencies = - cache.findKnownDependency(moduleID).getImportedClangDependencies(); - reachableClangModules.insert(dependencies.begin(), dependencies.end()); - } - discoveredClangModules.insert(reachableClangModules.begin(), - reachableClangModules.end()); - return found; - } - - // Otherwise perform filesystem scan - auto moduleIdentifier = getModuleImportIdentifier(moduleName); - auto moduleDependencies = withDependencyScanningWorker( - [&cache, moduleIdentifier](ModuleDependencyScanningWorker *ScanningWorker) { - return ScanningWorker->scanFilesystemForClangModuleDependency( - moduleIdentifier, cache.getModuleOutputPath(), - cache.getAlreadySeenClangModules(), - cache.getScanService().getPrefixMapper()); - }); - if (moduleDependencies.empty()) - return std::nullopt; - - discoveredClangModules.insert(moduleID); - for (const auto &dep : moduleDependencies) - discoveredClangModules.insert(dep.first); - - cache.recordDependencies(moduleDependencies); - return cache.findDependency(moduleID); -} - /// Retrieve the module dependencies for the Swift module with the given name. std::optional ModuleDependencyScanner::getNamedSwiftModuleDependencyInfo( From 214514da9284017ee762456fadea7fac0d7c37e6 Mon Sep 17 00:00:00 2001 From: Qiongsi Wu Date: Wed, 19 Mar 2025 20:40:19 -0700 Subject: [PATCH 2/4] Initial commit. Tests are passing. --- include/swift/AST/ModuleDependencies.h | 2 +- include/swift/ClangImporter/ClangImporter.h | 12 ++ .../DependencyScan/ModuleDependencyScanner.h | 9 ++ lib/AST/ModuleDependencies.cpp | 2 +- .../ClangModuleDependencyScanner.cpp | 79 +++++++++++- .../ModuleDependencyScanner.cpp | 116 ++++++++++++++---- 6 files changed, 187 insertions(+), 33 deletions(-) diff --git a/include/swift/AST/ModuleDependencies.h b/include/swift/AST/ModuleDependencies.h index 628dca2a8008a..6aeaf27a8cc63 100644 --- a/include/swift/AST/ModuleDependencies.h +++ b/include/swift/AST/ModuleDependencies.h @@ -1255,7 +1255,7 @@ class ModuleDependenciesCache { ModuleDependencyInfo dependencies); /// Record dependencies for the given module collection. - void recordDependencies(ModuleDependencyVector moduleDependencies); + void recordDependencies(const ModuleDependencyVector &moduleDependencies); /// Update stored dependencies for the given module. void updateDependency(ModuleDependencyID moduleID, diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h index cf96a7127ecd4..c4a642dba707a 100644 --- a/include/swift/ClangImporter/ClangImporter.h +++ b/include/swift/ClangImporter/ClangImporter.h @@ -495,6 +495,18 @@ class ClangImporter final : public ClangModuleLoader { llvm::PrefixMapper *mapper, bool isTestableImport = false) override; + // The moduleOutputPath specifies a directory where the precompiled modules + // reside in. It should not vary accross the list of modules. + llvm::SmallVector, 1> + getModuleDependencies( + ArrayRef moduleNames, StringRef moduleOutputPath, + const llvm::DenseSet + &alreadySeenClangModules, + clang::tooling::dependencies::DependencyScanningTool &clangScanningTool, + InterfaceSubContextDelegate &delegate, llvm::PrefixMapper *mapper, + llvm::StringSet<> &successModules, llvm::StringSet<> ¬FoundModules, + llvm::StringSet<> &errorModules, bool isTestableImport = false); + void recordBridgingHeaderOptions( ModuleDependencyInfo &MDI, const clang::tooling::dependencies::TranslationUnitDeps &deps); diff --git a/include/swift/DependencyScan/ModuleDependencyScanner.h b/include/swift/DependencyScan/ModuleDependencyScanner.h index 067463b9c4ab4..aedf44cf9dc23 100644 --- a/include/swift/DependencyScan/ModuleDependencyScanner.h +++ b/include/swift/DependencyScan/ModuleDependencyScanner.h @@ -43,6 +43,15 @@ class ModuleDependencyScanningWorker { const llvm::DenseSet &alreadySeenModules, llvm::PrefixMapper *prefixMapper); + /// Retrieve the module dependencies for a list of Clang modules given a list + /// of names. + ModuleDependencyVector scanFilesystemForClangModuleDependency( + ArrayRef moduleNames, StringRef moduleOutputPath, + const llvm::DenseSet + &alreadySeenModules, + llvm::PrefixMapper *prefixMapper, llvm::StringSet<> &successModules, + llvm::StringSet<> ¬FoundModules, llvm::StringSet<> &errorModules); + /// Retrieve the module dependencies for the Swift module with the given name. ModuleDependencyVector scanFilesystemForSwiftModuleDependency(Identifier moduleName, StringRef moduleOutputPath, diff --git a/lib/AST/ModuleDependencies.cpp b/lib/AST/ModuleDependencies.cpp index 38fe7e580b201..57d620c4b59aa 100644 --- a/lib/AST/ModuleDependencies.cpp +++ b/lib/AST/ModuleDependencies.cpp @@ -875,7 +875,7 @@ void ModuleDependenciesCache::recordDependency( } void ModuleDependenciesCache::recordDependencies( - ModuleDependencyVector dependencies) { + const ModuleDependencyVector &dependencies) { for (const auto &dep : dependencies) { if (!hasDependency(dep.first)) recordDependency(dep.first.ModuleName, dep.second); diff --git a/lib/ClangImporter/ClangModuleDependencyScanner.cpp b/lib/ClangImporter/ClangModuleDependencyScanner.cpp index 37e702ca29095..4d6d8cadfd651 100644 --- a/lib/ClangImporter/ClangModuleDependencyScanner.cpp +++ b/lib/ClangImporter/ClangModuleDependencyScanner.cpp @@ -422,16 +422,16 @@ ClangImporter::getModuleDependencies(Identifier moduleName, auto lookupModuleOutput = [moduleOutputPath](const ModuleID &MID, - ModuleOutputKind MOK) -> std::string { + ModuleOutputKind MOK) -> std::string { return moduleCacheRelativeLookupModuleOutput(MID, MOK, moduleOutputPath); }; - auto clangModuleDependencies = + auto [Error, clangModuleDependencies] = clangScanningTool.getModuleDependencies( moduleName.str(), commandLineArgs, workingDir, alreadySeenClangModules, lookupModuleOutput); - if (!clangModuleDependencies) { - auto errorStr = toString(clangModuleDependencies.takeError()); + if (Error) { + auto errorStr = toString(std::move(Error)); // We ignore the "module 'foo' not found" error, the Swift dependency // scanner will report such an error only if all of the module loaders // fail as well. @@ -443,7 +443,76 @@ ClangImporter::getModuleDependencies(Identifier moduleName, } return bridgeClangModuleDependencies(clangScanningTool, - *clangModuleDependencies, + clangModuleDependencies, + moduleOutputPath, [&](StringRef path) { + if (mapper) + return mapper->mapToString(path); + return path.str(); + }); +} + +ModuleDependencyVector ClangImporter::getModuleDependencies( + ArrayRef moduleNames, StringRef moduleOutputPath, + const llvm::DenseSet + &alreadySeenClangModules, + clang::tooling::dependencies::DependencyScanningTool &clangScanningTool, + InterfaceSubContextDelegate &delegate, llvm::PrefixMapper *mapper, + llvm::StringSet<> &successModules, llvm::StringSet<> ¬FoundModules, + llvm::StringSet<> &errorModules, bool isTestableImport) { + auto &ctx = Impl.SwiftContext; + // Determine the command-line arguments for dependency scanning. + std::vector commandLineArgs = + getClangDepScanningInvocationArguments(ctx); + auto optionalWorkingDir = computeClangWorkingDirectory(commandLineArgs, ctx); + if (!optionalWorkingDir) { + ctx.Diags.diagnose(SourceLoc(), diag::clang_dependency_scan_error, + "Missing '-working-directory' argument"); + return {}; + } + std::string workingDir = *optionalWorkingDir; + + auto lookupModuleOutput = + [moduleOutputPath](const ModuleID &MID, + ModuleOutputKind MOK) -> std::string { + return moduleCacheRelativeLookupModuleOutput(MID, MOK, moduleOutputPath); + }; + + auto [error, clangModuleDependencies] = + clangScanningTool.getModuleDependencies( + moduleNames, commandLineArgs, workingDir, alreadySeenClangModules, + lookupModuleOutput); + if (error) { + auto errorStr = toString(std::move(error)); + bool showError = false; + + // We partition the modules into three sets, modules successfully scanned, + // modules not found, and modules that incur scanning errors. + for (const auto &N : moduleNames) { + // We ignore the "module 'foo' not found" error, the Swift dependency + // scanner will report such an error only if all of the module loaders + // fail as well. + if (errorStr.find("error: module '" + N.str() + "' not found") == + std::string::npos) { + if (errorStr.find("'" + N.str() + "'") != std::string::npos) { + showError = true; + errorModules.insert(N); + } else + successModules.insert(N); + } else + notFoundModules.insert(N); + } + + if (showError) + ctx.Diags.diagnose(SourceLoc(), diag::clang_dependency_scan_error, + errorStr); + } else + successModules.insert(moduleNames.begin(), moduleNames.end()); + + if (!clangModuleDependencies.size()) + return {}; + + return bridgeClangModuleDependencies(clangScanningTool, + clangModuleDependencies, moduleOutputPath, [&](StringRef path) { if (mapper) return mapper->mapToString(path); diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp index b5914f4b2660f..1d389c2e571c2 100644 --- a/lib/DependencyScan/ModuleDependencyScanner.cpp +++ b/lib/DependencyScan/ModuleDependencyScanner.cpp @@ -259,6 +259,19 @@ ModuleDependencyScanningWorker::scanFilesystemForClangModuleDependency( *scanningASTDelegate, prefixMapper, false); } +ModuleDependencyVector +ModuleDependencyScanningWorker::scanFilesystemForClangModuleDependency( + ArrayRef moduleNames, StringRef moduleOutputPath, + const llvm::DenseSet + &alreadySeenModules, + llvm::PrefixMapper *prefixMapper, llvm::StringSet<> &successModules, + llvm::StringSet<> ¬FoundModules, llvm::StringSet<> &errorModules) { + return clangScannerModuleLoader->getModuleDependencies( + moduleNames, moduleOutputPath, alreadySeenModules, clangScanningTool, + *scanningASTDelegate, prefixMapper, successModules, notFoundModules, + errorModules, false); +} + template auto ModuleDependencyScanner::withDependencyScanningWorker(Function &&F, Args &&...ArgList) { @@ -849,48 +862,98 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( const llvm::DenseSet seenClangModules = cache.getAlreadySeenClangModules(); std::mutex cacheAccessLock; - auto scanForClangModuleDependency = - [this, &cache, &moduleLookupResult, - &cacheAccessLock, &seenClangModules](Identifier moduleIdentifier) { - auto moduleName = moduleIdentifier.str(); + + auto scanDependencyForListOfClangModules = + [this, &cache, &moduleLookupResult, &cacheAccessLock, + &seenClangModules](ArrayRef moduleIDs) { + std::vector unresolvedModules; { std::lock_guard guard(cacheAccessLock); - if (cache.hasDependency(moduleName, ModuleDependencyKind::Clang)) + // Check to see if there are any modules not resolved yet. + for (const auto &ID : moduleIDs) { + if (!cache.hasDependency(ID, ModuleDependencyKind::Clang)) + unresolvedModules.push_back(ID); + } + + // No unresolved modules remaining. + if (!unresolvedModules.size()) return; } + llvm::StringSet<> successModules; + llvm::StringSet<> notFoundModules; + llvm::StringSet<> errorModules; auto moduleDependencies = withDependencyScanningWorker( - [&cache, &seenClangModules, - moduleIdentifier](ModuleDependencyScanningWorker *ScanningWorker) { - return ScanningWorker->scanFilesystemForClangModuleDependency( - moduleIdentifier, cache.getModuleOutputPath(), - seenClangModules, cache.getScanService().getPrefixMapper()); + [&cache, &seenClangModules, &unresolvedModules, &successModules, + ¬FoundModules, + &errorModules](ModuleDependencyScanningWorker *scanningWorker) { + return scanningWorker->scanFilesystemForClangModuleDependency( + unresolvedModules, cache.getModuleOutputPath(), + seenClangModules, cache.getScanService().getPrefixMapper(), + successModules, notFoundModules, errorModules); }); - // Update the `moduleLookupResult` and cache all discovered dependencies - // so that subsequent queries do not have to call into the scanner - // if looking for a module that was discovered as a transitive dependency - // in this scan. { std::lock_guard guard(cacheAccessLock); - moduleLookupResult.insert_or_assign(moduleName, moduleDependencies); - if (!moduleDependencies.empty()) - cache.recordDependencies(moduleDependencies); + for (const auto &N : successModules.keys()) { + moduleLookupResult.insert_or_assign(N, moduleDependencies); + if (!moduleDependencies.empty()) + cache.recordDependencies(moduleDependencies); + } + + // FIXME: document the reason why we use an empty dependency + // vector as a placeholder for modules not found. + for (const auto &N : notFoundModules.keys()) { + moduleLookupResult.insert_or_assign(N, ModuleDependencyVector()); + } + + for (const auto &N : errorModules.keys()) { + moduleLookupResult.insert_or_assign(N, ModuleDependencyVector()); + } } }; - // Enque asynchronous lookup tasks - for (const auto &unresolvedIdentifier : unresolvedImportIdentifiers) - ScanningThreadPool.async( - scanForClangModuleDependency, - getModuleImportIdentifier(unresolvedIdentifier.getKey())); - for (const auto &unresolvedIdentifier : unresolvedOptionalImportIdentifiers) - ScanningThreadPool.async( - scanForClangModuleDependency, - getModuleImportIdentifier(unresolvedIdentifier.getKey())); + auto batchResolveModuleDependencies = [&](const auto &unreslovedModuleIDs) { + std::vector unresolvedModuleNames( + unreslovedModuleIDs.keys().begin(), unreslovedModuleIDs.keys().end()); + std::transform(unresolvedModuleNames.begin(), unresolvedModuleNames.end(), + unresolvedModuleNames.begin(), [&](auto Key) { + return getModuleImportIdentifier(Key).str(); + }); + auto chunkResults = std::div((int)unreslovedModuleIDs.size(), NumThreads); + const size_t chunkSize = chunkResults.quot; + const size_t remainingSize = chunkResults.rem; + + auto unresolvedModuleNamesIt = unresolvedModuleNames.begin(); + size_t numOfUnresolvedModules = unresolvedModuleNames.size(); + for (size_t i = 0; i + remainingSize < numOfUnresolvedModules; + i += chunkSize) { + std::vector batchedNames( + unresolvedModuleNamesIt, (unresolvedModuleNamesIt + chunkSize)); + ScanningThreadPool.async(scanDependencyForListOfClangModules, + batchedNames); + unresolvedModuleNamesIt += chunkSize; + } + + if (remainingSize) { + std::vector remainingNames( + unresolvedModuleNamesIt, (unresolvedModuleNamesIt + remainingSize)); + ScanningThreadPool.async(scanDependencyForListOfClangModules, + remainingNames); + } + }; + + batchResolveModuleDependencies(unresolvedImportIdentifiers); + batchResolveModuleDependencies(unresolvedOptionalImportIdentifiers); ScanningThreadPool.wait(); // Use the computed scan results to update the dependency info + // Four things + // 1. For each unresolved import, update the direct dependencies. Stored in + // importedClangDependencies. + // 2. Every single module we discovered goes into allDiscoveredClangModules. + // 3. Every single module we discovered goes into the `cache`. Happened above. + // 4. Record every single module that failed to resolve. for (const auto &moduleID : swiftModuleDependents) { std::vector failedToResolveImports; ModuleDependencyIDSetVector importedClangDependencies; @@ -923,6 +986,7 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( for (const auto &unresolvedImport : unresolvedImportsMap[moduleID]) recordResolvedClangModuleImport(unresolvedImport, false); + for (const auto &unresolvedImport : unresolvedOptionalImportsMap[moduleID]) recordResolvedClangModuleImport(unresolvedImport, true); From 701d1faed7278d209bc1b9df558f3b2b3f6f25bb Mon Sep 17 00:00:00 2001 From: Qiongsi Wu Date: Fri, 21 Mar 2025 13:07:44 -0700 Subject: [PATCH 3/4] Using ArrayRef slices for batching. --- .../ModuleDependencyScanner.cpp | 46 ++++++++++--------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp index 1d389c2e571c2..71f1c58f4c774 100644 --- a/lib/DependencyScan/ModuleDependencyScanner.cpp +++ b/lib/DependencyScan/ModuleDependencyScanner.cpp @@ -870,7 +870,7 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( { std::lock_guard guard(cacheAccessLock); // Check to see if there are any modules not resolved yet. - for (const auto &ID : moduleIDs) { + for (StringRef ID : moduleIDs) { if (!cache.hasDependency(ID, ModuleDependencyKind::Clang)) unresolvedModules.push_back(ID); } @@ -913,38 +913,42 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( } }; - auto batchResolveModuleDependencies = [&](const auto &unreslovedModuleIDs) { - std::vector unresolvedModuleNames( - unreslovedModuleIDs.keys().begin(), unreslovedModuleIDs.keys().end()); - std::transform(unresolvedModuleNames.begin(), unresolvedModuleNames.end(), - unresolvedModuleNames.begin(), [&](auto Key) { - return getModuleImportIdentifier(Key).str(); - }); - auto chunkResults = std::div((int)unreslovedModuleIDs.size(), NumThreads); + auto batchResolveModuleDependencies = [&](const auto &unresolvedModuleNames) { + auto chunkResults = std::div((int)unresolvedModuleNames.size(), NumThreads); const size_t chunkSize = chunkResults.quot; const size_t remainingSize = chunkResults.rem; - auto unresolvedModuleNamesIt = unresolvedModuleNames.begin(); size_t numOfUnresolvedModules = unresolvedModuleNames.size(); + ArrayRef namesRef(unresolvedModuleNames); + size_t current = 0; for (size_t i = 0; i + remainingSize < numOfUnresolvedModules; i += chunkSize) { - std::vector batchedNames( - unresolvedModuleNamesIt, (unresolvedModuleNamesIt + chunkSize)); - ScanningThreadPool.async(scanDependencyForListOfClangModules, - batchedNames); - unresolvedModuleNamesIt += chunkSize; + ArrayRef batch = namesRef.slice(current, chunkSize); + ScanningThreadPool.async(scanDependencyForListOfClangModules, batch); + current += chunkSize; } if (remainingSize) { - std::vector remainingNames( - unresolvedModuleNamesIt, (unresolvedModuleNamesIt + remainingSize)); - ScanningThreadPool.async(scanDependencyForListOfClangModules, - remainingNames); + ArrayRef batch = namesRef.slice(current, remainingSize); + ScanningThreadPool.async(scanDependencyForListOfClangModules, batch); } }; - batchResolveModuleDependencies(unresolvedImportIdentifiers); - batchResolveModuleDependencies(unresolvedOptionalImportIdentifiers); + auto getModuleNames = [&](const auto &unresolvedIdentifiers, + auto &unresolvedNames) { + llvm::for_each(unresolvedIdentifiers.keys(), [&](auto key) { + unresolvedNames.emplace_back(getModuleImportIdentifier(key).str()); + }); + }; + + std::vector unresolvedImportNames; + std::vector unresolvedOptionalImportNames; + getModuleNames(unresolvedImportIdentifiers, unresolvedImportNames); + getModuleNames(unresolvedOptionalImportIdentifiers, + unresolvedOptionalImportNames); + + batchResolveModuleDependencies(unresolvedImportNames); + batchResolveModuleDependencies(unresolvedOptionalImportNames); ScanningThreadPool.wait(); // Use the computed scan results to update the dependency info From 0821e4f5a0e3a4a67a834666df19335604cd62e5 Mon Sep 17 00:00:00 2001 From: Qiongsi Wu Date: Tue, 25 Mar 2025 12:27:36 -0700 Subject: [PATCH 4/4] Replacing the container for the partitioned module names. --- include/swift/ClangImporter/ClangImporter.h | 5 +++-- .../DependencyScan/ModuleDependencyScanner.h | 5 +++-- .../ClangModuleDependencyScanner.cpp | 14 ++++++++------ lib/DependencyScan/ModuleDependencyScanner.cpp | 17 +++++++++-------- 4 files changed, 23 insertions(+), 18 deletions(-) diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h index c4a642dba707a..ca2474ba9f1c0 100644 --- a/include/swift/ClangImporter/ClangImporter.h +++ b/include/swift/ClangImporter/ClangImporter.h @@ -504,8 +504,9 @@ class ClangImporter final : public ClangModuleLoader { &alreadySeenClangModules, clang::tooling::dependencies::DependencyScanningTool &clangScanningTool, InterfaceSubContextDelegate &delegate, llvm::PrefixMapper *mapper, - llvm::StringSet<> &successModules, llvm::StringSet<> ¬FoundModules, - llvm::StringSet<> &errorModules, bool isTestableImport = false); + std::vector &successModules, + std::vector ¬FoundModules, + std::vector &errorModules, bool isTestableImport = false); void recordBridgingHeaderOptions( ModuleDependencyInfo &MDI, diff --git a/include/swift/DependencyScan/ModuleDependencyScanner.h b/include/swift/DependencyScan/ModuleDependencyScanner.h index aedf44cf9dc23..742c6f5fa3852 100644 --- a/include/swift/DependencyScan/ModuleDependencyScanner.h +++ b/include/swift/DependencyScan/ModuleDependencyScanner.h @@ -49,8 +49,9 @@ class ModuleDependencyScanningWorker { ArrayRef moduleNames, StringRef moduleOutputPath, const llvm::DenseSet &alreadySeenModules, - llvm::PrefixMapper *prefixMapper, llvm::StringSet<> &successModules, - llvm::StringSet<> ¬FoundModules, llvm::StringSet<> &errorModules); + llvm::PrefixMapper *prefixMapper, std::vector &successModules, + std::vector ¬FoundModules, + std::vector &errorModules); /// Retrieve the module dependencies for the Swift module with the given name. ModuleDependencyVector diff --git a/lib/ClangImporter/ClangModuleDependencyScanner.cpp b/lib/ClangImporter/ClangModuleDependencyScanner.cpp index 4d6d8cadfd651..a0e37cd35beef 100644 --- a/lib/ClangImporter/ClangModuleDependencyScanner.cpp +++ b/lib/ClangImporter/ClangModuleDependencyScanner.cpp @@ -457,8 +457,9 @@ ModuleDependencyVector ClangImporter::getModuleDependencies( &alreadySeenClangModules, clang::tooling::dependencies::DependencyScanningTool &clangScanningTool, InterfaceSubContextDelegate &delegate, llvm::PrefixMapper *mapper, - llvm::StringSet<> &successModules, llvm::StringSet<> ¬FoundModules, - llvm::StringSet<> &errorModules, bool isTestableImport) { + std::vector &successModules, + std::vector ¬FoundModules, + std::vector &errorModules, bool isTestableImport) { auto &ctx = Impl.SwiftContext; // Determine the command-line arguments for dependency scanning. std::vector commandLineArgs = @@ -495,18 +496,19 @@ ModuleDependencyVector ClangImporter::getModuleDependencies( std::string::npos) { if (errorStr.find("'" + N.str() + "'") != std::string::npos) { showError = true; - errorModules.insert(N); + errorModules.push_back(N); } else - successModules.insert(N); + successModules.push_back(N); } else - notFoundModules.insert(N); + notFoundModules.push_back(N); } if (showError) ctx.Diags.diagnose(SourceLoc(), diag::clang_dependency_scan_error, errorStr); } else - successModules.insert(moduleNames.begin(), moduleNames.end()); + successModules.insert(successModules.end(), moduleNames.begin(), + moduleNames.end()); if (!clangModuleDependencies.size()) return {}; diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp index 71f1c58f4c774..450b27e17b618 100644 --- a/lib/DependencyScan/ModuleDependencyScanner.cpp +++ b/lib/DependencyScan/ModuleDependencyScanner.cpp @@ -264,8 +264,9 @@ ModuleDependencyScanningWorker::scanFilesystemForClangModuleDependency( ArrayRef moduleNames, StringRef moduleOutputPath, const llvm::DenseSet &alreadySeenModules, - llvm::PrefixMapper *prefixMapper, llvm::StringSet<> &successModules, - llvm::StringSet<> ¬FoundModules, llvm::StringSet<> &errorModules) { + llvm::PrefixMapper *prefixMapper, std::vector &successModules, + std::vector ¬FoundModules, + std::vector &errorModules) { return clangScannerModuleLoader->getModuleDependencies( moduleNames, moduleOutputPath, alreadySeenModules, clangScanningTool, *scanningASTDelegate, prefixMapper, successModules, notFoundModules, @@ -880,9 +881,9 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( return; } - llvm::StringSet<> successModules; - llvm::StringSet<> notFoundModules; - llvm::StringSet<> errorModules; + std::vector successModules; + std::vector notFoundModules; + std::vector errorModules; auto moduleDependencies = withDependencyScanningWorker( [&cache, &seenClangModules, &unresolvedModules, &successModules, ¬FoundModules, @@ -895,7 +896,7 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( { std::lock_guard guard(cacheAccessLock); - for (const auto &N : successModules.keys()) { + for (const auto &N : successModules) { moduleLookupResult.insert_or_assign(N, moduleDependencies); if (!moduleDependencies.empty()) cache.recordDependencies(moduleDependencies); @@ -903,11 +904,11 @@ ModuleDependencyScanner::resolveAllClangModuleDependencies( // FIXME: document the reason why we use an empty dependency // vector as a placeholder for modules not found. - for (const auto &N : notFoundModules.keys()) { + for (const auto &N : notFoundModules) { moduleLookupResult.insert_or_assign(N, ModuleDependencyVector()); } - for (const auto &N : errorModules.keys()) { + for (const auto &N : errorModules) { moduleLookupResult.insert_or_assign(N, ModuleDependencyVector()); } }