From a380103051fa0a99a27ed2b37cda5238ab7ee460 Mon Sep 17 00:00:00 2001 From: Artem Chikin Date: Thu, 10 Jul 2025 13:54:59 -0700 Subject: [PATCH] [Dependency Scanning] Reduce the amount of copying of collections of module IDs Previously, frequently-used methods like 'getAllDependencies' and 'getAllClangDependencies' had to aggregate (copy) multiple collections stored in a 'ModuleDependencyInfo' into a new result array to present to the client. These methods have been refactored to instead return an iterable joined view of the constituent collections. --- include/swift/AST/ModuleDependencies.h | 92 +++++++++++-- .../DependencyScan/ModuleDependencyScanner.h | 7 +- lib/AST/ModuleDependencies.cpp | 128 ++++++++---------- .../ModuleDependencyScanner.cpp | 57 ++++---- lib/DependencyScan/ScanDependencies.cpp | 5 +- test/CAS/module_deps_include_tree.swift | 50 +++---- test/CAS/plugin_cas.swift | 49 ++++--- .../module_deps_cache_reuse.swift | 38 +++--- 8 files changed, 241 insertions(+), 185 deletions(-) diff --git a/include/swift/AST/ModuleDependencies.h b/include/swift/AST/ModuleDependencies.h index 3739d7465eaf1..724a7607b6f1d 100644 --- a/include/swift/AST/ModuleDependencies.h +++ b/include/swift/AST/ModuleDependencies.h @@ -94,6 +94,69 @@ struct ModuleDependencyIDHash { } }; +// An iterable view over multiple joined ArrayRefs +// FIXME: std::ranges::join_view +template +class JoinedArrayRefView { +public: + class Iterator { + public: + using iterator_category = std::forward_iterator_tag; + using value_type = T; + using difference_type = std::ptrdiff_t; + using pointer = const T*; + using reference = const T&; + Iterator(const JoinedArrayRefView *parent, size_t memberIndex, + size_t elementIndex) + : parentView(parent), collectionIndex(memberIndex), + elementIndex(elementIndex) { + checkAdvance(); + } + const T &operator*() const { + return (parentView->memberCollections[collectionIndex])[elementIndex]; + } + const T *operator->() const { + return &(parentView->memberCollections[collectionIndex])[elementIndex]; + } + Iterator &operator++() { + ++elementIndex; + checkAdvance(); + return *this; + } + bool operator==(const Iterator &other) const { + return collectionIndex == other.collectionIndex && + elementIndex == other.elementIndex; + } + bool operator!=(const Iterator &other) const { return !(*this == other); } + + private: + const JoinedArrayRefView *parentView; + size_t collectionIndex; + size_t elementIndex; + + void checkAdvance() { + while (collectionIndex < parentView->memberCollections.size() && + elementIndex >= parentView->memberCollections[collectionIndex].size()) { + ++collectionIndex; + elementIndex = 0; + } + } + }; + + Iterator begin() const { return Iterator(this, 0, 0); } + Iterator end() const { return Iterator(this, memberCollections.size(), 0); } + + template + JoinedArrayRefView(Arrays ...arrs) { + memberCollections.reserve(sizeof...(arrs)); + (memberCollections.push_back(arrs), ...); + } + +private: + std::vector> memberCollections; +}; +using ModuleDependencyIDCollectionView = JoinedArrayRefView; + using ModuleDependencyIDSet = std::unordered_set; using ModuleDependencyIDSetVector = @@ -718,9 +781,8 @@ class ModuleDependencyInfo { ArrayRef getSwiftOverlayDependencies() const { return storage->swiftOverlayDependencies; } - - void - setCrossImportOverlayDependencies(const ArrayRef dependencyIDs) { + void setCrossImportOverlayDependencies( + const ModuleDependencyIDCollectionView dependencyIDs) { assert(isSwiftModule()); storage->crossImportOverlayModules.assign(dependencyIDs.begin(), dependencyIDs.end()); @@ -1051,12 +1113,16 @@ class ModuleDependenciesCache { } /// Query all dependencies - ModuleDependencyIDSetVector + ModuleDependencyIDCollectionView getAllDependencies(const ModuleDependencyID &moduleID) const; + /// Query all directly-imported dependencies + ModuleDependencyIDCollectionView + getDirectImportedDependencies(const ModuleDependencyID &moduleID) const; + /// Query all Clang module dependencies. - ModuleDependencyIDSetVector - getClangDependencies(const ModuleDependencyID &moduleID) const; + ModuleDependencyIDCollectionView + getAllClangDependencies(const ModuleDependencyID &moduleID) const; /// Query all directly-imported Swift dependencies llvm::ArrayRef @@ -1138,9 +1204,17 @@ class ModuleDependenciesCache { setHeaderClangDependencies(ModuleDependencyID moduleID, const ArrayRef dependencyIDs); /// Resolve this module's cross-import overlay dependencies - void - setCrossImportOverlayDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs); + void setCrossImportOverlayDependencies( + ModuleDependencyID moduleID, + const ModuleDependencyIDCollectionView dependencyIDs) { + auto dependencyInfo = findKnownDependency(moduleID); + assert(dependencyInfo.getCrossImportOverlayDependencies().empty()); + // Copy the existing info to a mutable one we can then replace it with, + // after setting its overlay dependencies. + auto updatedDependencyInfo = dependencyInfo; + updatedDependencyInfo.setCrossImportOverlayDependencies(dependencyIDs); + updateDependency(moduleID, updatedDependencyInfo); + } /// Add to this module's set of visible Clang modules void addVisibleClangModules(ModuleDependencyID moduleID, diff --git a/include/swift/DependencyScan/ModuleDependencyScanner.h b/include/swift/DependencyScan/ModuleDependencyScanner.h index 6bc8a4ddc3c59..582396b448486 100644 --- a/include/swift/DependencyScan/ModuleDependencyScanner.h +++ b/include/swift/DependencyScan/ModuleDependencyScanner.h @@ -248,9 +248,10 @@ class ModuleDependencyScanner { /// (bridging headers) /// 4. Swift overlay modules of all of the transitively imported Clang modules /// that have one - ModuleDependencyIDSetVector - resolveImportedModuleDependencies(const ModuleDependencyID &rootModuleID, - ModuleDependenciesCache &cache); + void + resolveImportedModuleDependencies( + const ModuleDependencyID &rootModuleID, ModuleDependenciesCache &cache, + ModuleDependencyIDSetVector &allModules); void resolveSwiftModuleDependencies( const ModuleDependencyID &rootModuleID, ModuleDependenciesCache &cache, ModuleDependencyIDSetVector &discoveredSwiftModules); diff --git a/lib/AST/ModuleDependencies.cpp b/lib/AST/ModuleDependencies.cpp index ae2ba45e722af..ccc5e505eaaae 100644 --- a/lib/AST/ModuleDependencies.cpp +++ b/lib/AST/ModuleDependencies.cpp @@ -850,74 +850,79 @@ void ModuleDependenciesCache::removeDependency(ModuleDependencyID moduleID) { map.erase(moduleID.ModuleName); } -void -ModuleDependenciesCache::setImportedSwiftDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs) { +void ModuleDependenciesCache::setImportedSwiftDependencies( + ModuleDependencyID moduleID, + const ArrayRef dependencyIDs) { auto dependencyInfo = findKnownDependency(moduleID); assert(dependencyInfo.getImportedSwiftDependencies().empty()); #ifndef NDEBUG for (const auto &depID : dependencyIDs) assert(depID.Kind != ModuleDependencyKind::Clang); #endif - // Copy the existing info to a mutable one we can then replace it with, after setting its overlay dependencies. + // Copy the existing info to a mutable one we can then replace it with, after + // setting its overlay dependencies. auto updatedDependencyInfo = dependencyInfo; updatedDependencyInfo.setImportedSwiftDependencies(dependencyIDs); updateDependency(moduleID, updatedDependencyInfo); } -void -ModuleDependenciesCache::setImportedClangDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs) { +void ModuleDependenciesCache::setImportedClangDependencies( + ModuleDependencyID moduleID, + const ArrayRef dependencyIDs) { auto dependencyInfo = findKnownDependency(moduleID); assert(dependencyInfo.getImportedClangDependencies().empty()); #ifndef NDEBUG for (const auto &depID : dependencyIDs) assert(depID.Kind == ModuleDependencyKind::Clang); #endif - // Copy the existing info to a mutable one we can then replace it with, after setting its overlay dependencies. + // Copy the existing info to a mutable one we can then replace it with, after + // setting its overlay dependencies. auto updatedDependencyInfo = dependencyInfo; updatedDependencyInfo.setImportedClangDependencies(dependencyIDs); updateDependency(moduleID, updatedDependencyInfo); } -void -ModuleDependenciesCache::setHeaderClangDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs) { +void ModuleDependenciesCache::setHeaderClangDependencies( + ModuleDependencyID moduleID, + const ArrayRef dependencyIDs) { auto dependencyInfo = findKnownDependency(moduleID); #ifndef NDEBUG for (const auto &depID : dependencyIDs) assert(depID.Kind == ModuleDependencyKind::Clang); #endif - // Copy the existing info to a mutable one we can then replace it with, after setting its overlay dependencies. + // Copy the existing info to a mutable one we can then replace it with, after + // setting its overlay dependencies. auto updatedDependencyInfo = dependencyInfo; updatedDependencyInfo.setHeaderClangDependencies(dependencyIDs); updateDependency(moduleID, updatedDependencyInfo); } -void ModuleDependenciesCache::setSwiftOverlayDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs) { +void ModuleDependenciesCache::setSwiftOverlayDependencies( + ModuleDependencyID moduleID, + const ArrayRef dependencyIDs) { auto dependencyInfo = findKnownDependency(moduleID); assert(dependencyInfo.getSwiftOverlayDependencies().empty()); #ifndef NDEBUG for (const auto &depID : dependencyIDs) assert(depID.Kind != ModuleDependencyKind::Clang); #endif - // Copy the existing info to a mutable one we can then replace it with, after setting its overlay dependencies. + // Copy the existing info to a mutable one we can then replace it with, after + // setting its overlay dependencies. auto updatedDependencyInfo = dependencyInfo; updatedDependencyInfo.setSwiftOverlayDependencies(dependencyIDs); updateDependency(moduleID, updatedDependencyInfo); } -void -ModuleDependenciesCache::setCrossImportOverlayDependencies(ModuleDependencyID moduleID, - const ArrayRef dependencyIDs) { - auto dependencyInfo = findKnownDependency(moduleID); - assert(dependencyInfo.getCrossImportOverlayDependencies().empty()); - // Copy the existing info to a mutable one we can then replace it with, after setting its overlay dependencies. - auto updatedDependencyInfo = dependencyInfo; - updatedDependencyInfo.setCrossImportOverlayDependencies(dependencyIDs); - updateDependency(moduleID, updatedDependencyInfo); + +ModuleDependencyIDCollectionView ModuleDependenciesCache::getAllDependencies( + const ModuleDependencyID &moduleID) const { + const auto &moduleInfo = findKnownDependency(moduleID); + return ModuleDependencyIDCollectionView( + moduleInfo.getImportedSwiftDependencies(), + moduleInfo.getImportedClangDependencies(), + moduleInfo.getHeaderClangDependencies(), + moduleInfo.getSwiftOverlayDependencies(), + moduleInfo.getCrossImportOverlayDependencies()); } -void -ModuleDependenciesCache::addVisibleClangModules(ModuleDependencyID moduleID, - const std::vector &moduleNames) { +void ModuleDependenciesCache::addVisibleClangModules( + ModuleDependencyID moduleID, const std::vector &moduleNames) { if (moduleNames.empty()) return; auto dependencyInfo = findKnownDependency(moduleID); @@ -926,88 +931,67 @@ ModuleDependenciesCache::addVisibleClangModules(ModuleDependencyID moduleID, updateDependency(moduleID, updatedDependencyInfo); } -llvm::StringSet<> &ModuleDependenciesCache::getVisibleClangModules(ModuleDependencyID moduleID) const { +llvm::StringSet<> &ModuleDependenciesCache::getVisibleClangModules( + ModuleDependencyID moduleID) const { ASSERT(moduleID.Kind == ModuleDependencyKind::SwiftSource || moduleID.Kind == ModuleDependencyKind::SwiftInterface || moduleID.Kind == ModuleDependencyKind::SwiftBinary); return findKnownDependency(moduleID).getVisibleClangModules(); } -ModuleDependencyIDSetVector -ModuleDependenciesCache::getAllDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependencyIDCollectionView +ModuleDependenciesCache::getDirectImportedDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); - ModuleDependencyIDSetVector result; - if (moduleInfo.isSwiftModule()) { - auto swiftImportedDepsRef = moduleInfo.getImportedSwiftDependencies(); - auto headerClangDepsRef = moduleInfo.getHeaderClangDependencies(); - auto overlayDependenciesRef = moduleInfo.getSwiftOverlayDependencies(); - result.insert(swiftImportedDepsRef.begin(), - swiftImportedDepsRef.end()); - result.insert(headerClangDepsRef.begin(), - headerClangDepsRef.end()); - result.insert(overlayDependenciesRef.begin(), - overlayDependenciesRef.end()); - } - - if (moduleInfo.isSwiftSourceModule()) { - auto crossImportOverlayDepsRef = moduleInfo.getCrossImportOverlayDependencies(); - result.insert(crossImportOverlayDepsRef.begin(), - crossImportOverlayDepsRef.end()); - } - - auto clangImportedDepsRef = moduleInfo.getImportedClangDependencies(); - result.insert(clangImportedDepsRef.begin(), - clangImportedDepsRef.end()); - - return result; + return ModuleDependencyIDCollectionView( + moduleInfo.getImportedSwiftDependencies(), + moduleInfo.getImportedClangDependencies()); } -ModuleDependencyIDSetVector -ModuleDependenciesCache::getClangDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependencyIDCollectionView +ModuleDependenciesCache::getAllClangDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); - ModuleDependencyIDSetVector result; - auto clangImportedDepsRef = moduleInfo.getImportedClangDependencies(); - result.insert(clangImportedDepsRef.begin(), - clangImportedDepsRef.end()); - if (moduleInfo.isSwiftSourceModule() || moduleInfo.isSwiftBinaryModule()) { - auto headerClangDepsRef = moduleInfo.getHeaderClangDependencies(); - result.insert(headerClangDepsRef.begin(), - headerClangDepsRef.end()); - } - return result; + return ModuleDependencyIDCollectionView( + moduleInfo.getImportedClangDependencies(), + moduleInfo.getHeaderClangDependencies()); } llvm::ArrayRef -ModuleDependenciesCache::getImportedSwiftDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependenciesCache::getImportedSwiftDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); assert(moduleInfo.isSwiftModule()); return moduleInfo.getImportedSwiftDependencies(); } llvm::ArrayRef -ModuleDependenciesCache::getImportedClangDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependenciesCache::getImportedClangDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); return moduleInfo.getImportedClangDependencies(); } llvm::ArrayRef -ModuleDependenciesCache::getHeaderClangDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependenciesCache::getHeaderClangDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); assert(moduleInfo.isSwiftModule()); return moduleInfo.getHeaderClangDependencies(); } llvm::ArrayRef -ModuleDependenciesCache::getSwiftOverlayDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependenciesCache::getSwiftOverlayDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); assert(moduleInfo.isSwiftModule()); return moduleInfo.getSwiftOverlayDependencies(); } llvm::ArrayRef -ModuleDependenciesCache::getCrossImportOverlayDependencies(const ModuleDependencyID &moduleID) const { +ModuleDependenciesCache::getCrossImportOverlayDependencies( + const ModuleDependencyID &moduleID) const { const auto &moduleInfo = findKnownDependency(moduleID); assert(moduleInfo.isSwiftSourceModule()); return moduleInfo.getCrossImportOverlayDependencies(); } - diff --git a/lib/DependencyScan/ModuleDependencyScanner.cpp b/lib/DependencyScan/ModuleDependencyScanner.cpp index 858281081b0e3..12f4bf731fc9f 100644 --- a/lib/DependencyScan/ModuleDependencyScanner.cpp +++ b/lib/DependencyScan/ModuleDependencyScanner.cpp @@ -623,7 +623,7 @@ static void findAllImportedClangModules(StringRef moduleName, if (!optionalDependencies.has_value()) return; - for (const auto &dep : cache.getClangDependencies(moduleID)) + for (const auto &dep : cache.getAllClangDependencies(moduleID)) findAllImportedClangModules(dep.ModuleName, cache, allModules, knownModules); } @@ -934,8 +934,8 @@ ModuleDependencyScanner::performDependencyScan(ModuleDependencyID rootModuleID, // 4. Swift Overlay modules of imported Clang modules // This may call into 'resolveImportedModuleDependencies' // for the newly-added Swift overlay dependencies. - ModuleDependencyIDSetVector allModules = - resolveImportedModuleDependencies(rootModuleID, cache); + ModuleDependencyIDSetVector allModules; + resolveImportedModuleDependencies(rootModuleID, cache, allModules); // 5. Resolve cross-import overlays // This must only be done for the main source module, since textual and @@ -957,13 +957,13 @@ ModuleDependencyScanner::performDependencyScan(ModuleDependencyID rootModuleID, return allModules.takeVector(); } -ModuleDependencyIDSetVector +void ModuleDependencyScanner::resolveImportedModuleDependencies( - const ModuleDependencyID &rootModuleID, ModuleDependenciesCache &cache) { + const ModuleDependencyID &rootModuleID, ModuleDependenciesCache &cache, + ModuleDependencyIDSetVector &allModules) { PrettyStackTraceStringAction trace( "Resolving transitive closure of dependencies of: ", rootModuleID.ModuleName); - ModuleDependencyIDSetVector allModules; // Resolve all imports for which a Swift module can be found, // transitively, starting at 'rootModuleID'. @@ -972,25 +972,25 @@ ModuleDependencyScanner::resolveImportedModuleDependencies( allModules.insert(discoveredSwiftModules.begin(), discoveredSwiftModules.end()); - ModuleDependencyIDSetVector discoveredClangModules; + // Resolve all remaining unresolved imports for which no Swift + // module could be found, assuming them to be Clang modules. + // This operation is done by gathering all unresolved import + // identifiers and querying them in-parallel to the Clang + // dependency scanner. resolveAllClangModuleDependencies(discoveredSwiftModules.getArrayRef(), cache, - discoveredClangModules); - allModules.insert(discoveredClangModules.begin(), - discoveredClangModules.end()); + allModules); - ModuleDependencyIDSetVector discoveredHeaderDependencyClangModules; + // For each discovered Swift module which was built with a + // bridging header, scan the header for module dependencies. + // This includes the source module bridging header. resolveHeaderDependencies(discoveredSwiftModules.getArrayRef(), cache, - discoveredHeaderDependencyClangModules); - allModules.insert(discoveredHeaderDependencyClangModules.begin(), - discoveredHeaderDependencyClangModules.end()); + allModules); - ModuleDependencyIDSetVector discoveredSwiftOverlayDependencyModules; + // For each Swift module which imports Clang modules, + // query whether all visible Clang dependencies from such imports + // have a Swift overaly module. resolveSwiftOverlayDependencies(discoveredSwiftModules.getArrayRef(), cache, - discoveredSwiftOverlayDependencyModules); - allModules.insert(discoveredSwiftOverlayDependencyModules.begin(), - discoveredSwiftOverlayDependencyModules.end()); - - return allModules; + allModules); } void ModuleDependencyScanner::resolveSwiftModuleDependencies( @@ -1281,8 +1281,8 @@ void ModuleDependencyScanner::resolveSwiftOverlayDependencies( // For each additional Swift overlay dependency, ensure we perform a full scan // in case it itself has unresolved module dependencies. for (const auto &overlayDepID : discoveredSwiftOverlays) { - ModuleDependencyIDSetVector allNewModules = - resolveImportedModuleDependencies(overlayDepID, cache); + ModuleDependencyIDSetVector allNewModules; + resolveImportedModuleDependencies(overlayDepID, cache, allNewModules); allDiscoveredDependencies.insert(allNewModules.begin(), allNewModules.end()); } @@ -1485,7 +1485,7 @@ void ModuleDependencyScanner::resolveSwiftOverlayDependenciesForModule( llvm::StringSet<> knownModules; // Find all of the discovered Clang modules that this module depends on. - for (const auto &dep : cache.getClangDependencies(moduleID)) + for (const auto &dep : cache.getAllClangDependencies(moduleID)) findAllImportedClangModules(dep.ModuleName, cache, allClangDependencies, knownModules); @@ -1634,16 +1634,15 @@ void ModuleDependencyScanner::resolveCrossImportOverlayDependencies( else cache.recordDependency(dummyMainName, dummyMainDependencies); - ModuleDependencyIDSetVector allModules = - resolveImportedModuleDependencies(dummyMainID, cache); + ModuleDependencyIDSetVector allModules; + resolveImportedModuleDependencies(dummyMainID, cache, allModules); // Update main module's dependencies to include these new overlays. - auto newOverlayDeps = cache.getAllDependencies(dummyMainID); cache.setCrossImportOverlayDependencies(actualMainID, - newOverlayDeps.getArrayRef()); + cache.getAllDependencies(dummyMainID)); - // Update the command-line on the main module to - // disable implicit cross-import overlay search. + // Update the command-line on the main module to disable implicit + // cross-import overlay search. auto mainDep = cache.findKnownDependency(actualMainID); std::vector cmdCopy = mainDep.getCommandline(); cmdCopy.push_back("-disable-cross-import-overlay-search"); diff --git a/lib/DependencyScan/ScanDependencies.cpp b/lib/DependencyScan/ScanDependencies.cpp index e78151de2eb71..b7dfc2557df9f 100644 --- a/lib/DependencyScan/ScanDependencies.cpp +++ b/lib/DependencyScan/ScanDependencies.cpp @@ -688,7 +688,7 @@ static bool writeJSONToOutput(DiagnosticEngine &diags, } static void -bridgeDependencyIDs(const ArrayRef dependencies, +bridgeDependencyIDs(const ModuleDependencyIDCollectionView dependencies, std::vector &bridgedDependencyNames) { for (const auto &dep : dependencies) { std::string dependencyKindAndName; @@ -925,8 +925,7 @@ static swiftscan_dependency_graph_t generateFullDependencyGraph( // Create a direct dependencies set according to the output format std::vector bridgedDependencyNames; - bridgeDependencyIDs(directDependencies.getArrayRef(), - bridgedDependencyNames); + bridgeDependencyIDs(directDependencies, bridgedDependencyNames); moduleInfo->direct_dependencies = create_set(bridgedDependencyNames); moduleInfo->details = getModuleDetails(); diff --git a/test/CAS/module_deps_include_tree.swift b/test/CAS/module_deps_include_tree.swift index 5ae9d06981603..6b4730f5644bc 100644 --- a/test/CAS/module_deps_include_tree.swift +++ b/test/CAS/module_deps_include_tree.swift @@ -84,6 +84,31 @@ import SubE // CHECK-DAG: "swift": "A" // CHECK-DAG: "swift": "F" +/// --------Swift module F +// CHECK: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", +// CHECK-NEXT: "sourceFiles": [ +// CHECK-NEXT: ], +// CHECK-NEXT: "directDependencies": [ +// CHECK-NEXT: { +// CHECK-DAG: "clang": "F" +// CHECK-DAG: "swift": "Swift" +// CHECK-DAG: "swift": "SwiftOnoneSupport" +// CHECK-NEXT: } +// CHECK-NEXT: ], +// CHECK: "details": +// CHECK: "moduleCacheKey": + +/// --------Swift module A +// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", + +// CHECK: directDependencies +// CHECK-NEXT: { +// CHECK-DAG: "clang": "A" +// CHECK-DAG: "swift": "Swift" +// CHECK-NEXT: } +// CHECK: "details": +// CHECK: "moduleCacheKey": + /// --------Clang module C // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}C-{{.*}}.pcm", @@ -123,31 +148,6 @@ import SubE // CHECK-MAKE-DEPS-SAME: BridgingOther.h // CHECK-MAKE-DEPS-SAME: module.modulemap -/// --------Swift module F -// CHECK: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", -// CHECK-NEXT: "sourceFiles": [ -// CHECK-NEXT: ], -// CHECK-NEXT: "directDependencies": [ -// CHECK-NEXT: { -// CHECK-DAG: "clang": "F" -// CHECK-DAG: "swift": "Swift" -// CHECK-DAG: "swift": "SwiftOnoneSupport" -// CHECK-NEXT: } -// CHECK-NEXT: ], -// CHECK: "details": -// CHECK: "moduleCacheKey": - -/// --------Swift module A -// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", - -// CHECK: directDependencies -// CHECK-NEXT: { -// CHECK-DAG: "clang": "A" -// CHECK-DAG: "swift": "Swift" -// CHECK-NEXT: } -// CHECK: "details": -// CHECK: "moduleCacheKey": - /// --------Swift module G // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}G-{{.*}}.swiftmodule" // CHECK: "directDependencies" diff --git a/test/CAS/plugin_cas.swift b/test/CAS/plugin_cas.swift index 735fc133d5b9c..591a2c574af75 100644 --- a/test/CAS/plugin_cas.swift +++ b/test/CAS/plugin_cas.swift @@ -74,6 +74,30 @@ import SubE // CHECK-DAG: "swift": "A" // CHECK-DAG: "swift": "F" +/// --------Swift module F +// CHECK: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", +// CHECK-NEXT: "sourceFiles": [ +// CHECK-NEXT: ], +// CHECK-NEXT: "directDependencies": [ +// CHECK-NEXT: { +// CHECK-DAG: "clang": "F" +// CHECK-DAG: "swift": "Swift" +// CHECK-DAG: "swift": "SwiftOnoneSupport" +// CHECK-NEXT: } +// CHECK-NEXT: ], +// CHECK: "details": +// CHECK: "moduleCacheKey": + +/// --------Swift module A +// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", + +// CHECK: directDependencies +// CHECK-NEXT: { +// CHECK-DAG: "clang": "A" +// CHECK-DAG: "swift": "Swift" +// CHECK-NEXT: } +// CHECK: "details": +// CHECK: "moduleCacheKey": /// --------Clang module C // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}C-{{.*}}.pcm", @@ -107,31 +131,6 @@ import SubE // CHECK-MAKE-DEPS-SAME: BridgingOther.h // CHECK-MAKE-DEPS-SAME: module.modulemap -/// --------Swift module F -// CHECK: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", -// CHECK-NEXT: "sourceFiles": [ -// CHECK-NEXT: ], -// CHECK-NEXT: "directDependencies": [ -// CHECK-NEXT: { -// CHECK-DAG: "clang": "F" -// CHECK-DAG: "swift": "Swift" -// CHECK-DAG: "swift": "SwiftOnoneSupport" -// CHECK-NEXT: } -// CHECK-NEXT: ], -// CHECK: "details": -// CHECK: "moduleCacheKey": - -/// --------Swift module A -// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", - -// CHECK: directDependencies -// CHECK-NEXT: { -// CHECK-DAG: "clang": "A" -// CHECK-DAG: "swift": "Swift" -// CHECK-NEXT: } -// CHECK: "details": -// CHECK: "moduleCacheKey": - /// --------Swift module G // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}G-{{.*}}.swiftmodule" // CHECK: "directDependencies" diff --git a/test/ScanDependencies/module_deps_cache_reuse.swift b/test/ScanDependencies/module_deps_cache_reuse.swift index 2d2d8eba9a45a..6c51440709cac 100644 --- a/test/ScanDependencies/module_deps_cache_reuse.swift +++ b/test/ScanDependencies/module_deps_cache_reuse.swift @@ -62,6 +62,25 @@ import SubE // CHECK-DAG: "swift": "F" // CHECK-DAG: "swift": "A" +/// --------Swift module F +// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", +// CHECK-NEXT: "sourceFiles": [ +// CHECK-NEXT: ], +// CHECK-NEXT: "directDependencies": [ +// CHECK-NEXT: { +// CHECK-DAG: "clang": "F" +// CHECK-DAG: "swift": "Swift" +// CHECK-DAG: "swift": "SwiftOnoneSupport" +// CHECK: ], + +/// --------Swift module A +// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", + +// CHECK: directDependencies +// CHECK-NEXT: { +// CHECK-DAG: "clang": "A" +// CHECK-DAG: "swift": "Swift" + /// --------Clang module C // CHECK-LABEL: "modulePath": "{{.*}}/C-{{.*}}.pcm", @@ -99,25 +118,6 @@ import SubE // CHECK: "clang": "A" // CHECK-NEXT: } -/// --------Swift module F -// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule", -// CHECK-NEXT: "sourceFiles": [ -// CHECK-NEXT: ], -// CHECK-NEXT: "directDependencies": [ -// CHECK-NEXT: { -// CHECK-DAG: "clang": "F" -// CHECK-DAG: "swift": "Swift" -// CHECK-DAG: "swift": "SwiftOnoneSupport" -// CHECK: ], - -/// --------Swift module A -// CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}A-{{.*}}.swiftmodule", - -// CHECK: directDependencies -// CHECK-NEXT: { -// CHECK-DAG: "clang": "A" -// CHECK-DAG: "swift": "Swift" - /// --------Swift module G // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}G-{{.*}}.swiftmodule" // CHECK: "directDependencies"