Skip to content

Commit 8eddd14

Browse files
dfsweeneydfsweeney
committed
Converting ModuleDecl::ImportedModule from std::pair to a dedicated struct.
1 parent bb9a41e commit 8eddd14

25 files changed

+211
-171
lines changed

‎include/swift/AST/Module.h‎

Lines changed: 32 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -209,26 +209,46 @@ class ModuleDecl : public DeclContext, public TypeDecl {
209209

210210
public:
211211
typedef ArrayRef<Located<Identifier>> AccessPathTy;
212-
typedef std::pair<ModuleDecl::AccessPathTy, ModuleDecl*> ImportedModule;
213-
212+
/// Convenience struct to keep track of a module along with its access path.
213+
struct ImportedModule {
214+
/// The access path from an import: `import Foo.Bar` -> `Foo.Bar`.
215+
ModuleDecl::AccessPathTy accessPath;
216+
/// The actual module corresponding to the import.
217+
///
218+
/// Invariant: The pointer is non-null.
219+
ModuleDecl *importedModule;
220+
221+
ImportedModule(ModuleDecl::AccessPathTy accessPath,
222+
ModuleDecl *importedModule)
223+
: accessPath(accessPath), importedModule(importedModule) {
224+
assert(this->importedModule);
225+
}
226+
227+
bool operator==(const ModuleDecl::ImportedModule &other) const {
228+
return (this->importedModule == other.importedModule) &&
229+
(this->accessPath == other.accessPath);
230+
}
231+
};
232+
214233
static bool matchesAccessPath(AccessPathTy AccessPath, DeclName Name) {
215234
assert(AccessPath.size() <= 1 && "can only refer to top-level decls");
216235

217236
return AccessPath.empty()
218237
|| DeclName(AccessPath.front().Item).matchesRef(Name);
219238
}
220-
239+
221240
/// Arbitrarily orders ImportedModule records, for inclusion in sets and such.
222241
class OrderImportedModules {
223242
public:
224243
bool operator()(const ImportedModule &lhs,
225244
const ImportedModule &rhs) const {
226-
if (lhs.second != rhs.second)
227-
return std::less<const ModuleDecl *>()(lhs.second, rhs.second);
228-
if (lhs.first.data() != rhs.first.data())
229-
return std::less<AccessPathTy::iterator>()(lhs.first.begin(),
230-
rhs.first.begin());
231-
return lhs.first.size() < rhs.first.size();
245+
if (lhs.importedModule != rhs.importedModule)
246+
return std::less<const ModuleDecl *>()(lhs.importedModule,
247+
rhs.importedModule);
248+
if (lhs.accessPath.data() != rhs.accessPath.data())
249+
return std::less<AccessPathTy::iterator>()(lhs.accessPath.begin(),
250+
rhs.accessPath.begin());
251+
return lhs.accessPath.size() < rhs.accessPath.size();
232252
}
233253
};
234254

@@ -860,14 +880,14 @@ namespace llvm {
860880
}
861881

862882
static unsigned getHashValue(const ModuleDecl::ImportedModule &val) {
863-
auto pair = std::make_pair(val.first.size(), val.second);
883+
auto pair = std::make_pair(val.accessPath.size(), val.importedModule);
864884
return llvm::DenseMapInfo<decltype(pair)>::getHashValue(pair);
865885
}
866886

867887
static bool isEqual(const ModuleDecl::ImportedModule &lhs,
868888
const ModuleDecl::ImportedModule &rhs) {
869-
return lhs.second == rhs.second &&
870-
ModuleDecl::isSameAccessPath(lhs.first, rhs.first);
889+
return lhs.importedModule == rhs.importedModule &&
890+
ModuleDecl::isSameAccessPath(lhs.accessPath, rhs.accessPath);
871891
}
872892
};
873893
}

‎lib/AST/AutoDiff.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@ bool swift::isDifferentiableProgrammingEnabled(SourceFile &SF) {
134134
// the given source file.
135135
bool importsDifferentiationModule = false;
136136
for (auto import : namelookup::getAllImports(&SF)) {
137-
if (import.second->getName() == ctx.Id_Differentiation) {
137+
if (import.importedModule->getName() == ctx.Id_Differentiation) {
138138
importsDifferentiationModule = true;
139139
break;
140140
}

‎lib/AST/ImportCache.cpp‎

Lines changed: 23 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -55,25 +55,26 @@ void ImportSet::Profile(
5555
ArrayRef<ModuleDecl::ImportedModule> topLevelImports) {
5656
ID.AddInteger(topLevelImports.size());
5757
for (auto import : topLevelImports) {
58-
ID.AddInteger(import.first.size());
59-
for (auto accessPathElt : import.first) {
58+
ID.AddInteger(import.accessPath.size());
59+
for (auto accessPathElt : import.accessPath) {
6060
ID.AddPointer(accessPathElt.Item.getAsOpaquePointer());
6161
}
62-
ID.AddPointer(import.second);
62+
ID.AddPointer(import.importedModule);
6363
}
6464
}
6565

6666
static void collectExports(ModuleDecl::ImportedModule next,
6767
SmallVectorImpl<ModuleDecl::ImportedModule> &stack) {
6868
SmallVector<ModuleDecl::ImportedModule, 4> exports;
69-
next.second->getImportedModulesForLookup(exports);
69+
next.importedModule->getImportedModulesForLookup(exports);
7070
for (auto exported : exports) {
71-
if (next.first.empty())
71+
if (next.accessPath.empty())
7272
stack.push_back(exported);
73-
else if (exported.first.empty()) {
74-
exported.first = next.first;
73+
else if (exported.accessPath.empty()) {
74+
exported.accessPath = next.accessPath;
7575
stack.push_back(exported);
76-
} else if (ModuleDecl::isSameAccessPath(next.first, exported.first)) {
76+
} else if (ModuleDecl::isSameAccessPath(next.accessPath,
77+
exported.accessPath)) {
7778
stack.push_back(exported);
7879
}
7980
}
@@ -97,7 +98,7 @@ ImportCache::getImportSet(ASTContext &ctx,
9798
continue;
9899

99100
topLevelImports.push_back(next);
100-
if (next.second == headerImportModule)
101+
if (next.importedModule == headerImportModule)
101102
hasHeaderImportModule = true;
102103
}
103104

@@ -127,7 +128,7 @@ ImportCache::getImportSet(ASTContext &ctx,
127128
continue;
128129

129130
transitiveImports.push_back(next);
130-
if (next.second == headerImportModule)
131+
if (next.importedModule == headerImportModule)
131132
hasHeaderImportModule = true;
132133

133134
collectExports(next, stack);
@@ -173,7 +174,9 @@ ImportSet &ImportCache::getImportSet(const DeclContext *dc) {
173174
ctx.Stats->getFrontendCounters().ImportSetCacheMiss++;
174175

175176
SmallVector<ModuleDecl::ImportedModule, 4> imports;
176-
imports.emplace_back(ModuleDecl::AccessPathTy(), mod);
177+
178+
imports.emplace_back(
179+
ModuleDecl::ImportedModule{ModuleDecl::AccessPathTy(), mod});
177180

178181
if (file) {
179182
ModuleDecl::ImportFilter importFilter;
@@ -220,10 +223,10 @@ ImportCache::getAllVisibleAccessPaths(const ModuleDecl *mod,
220223
SmallVector<ModuleDecl::AccessPathTy, 1> accessPaths;
221224
for (auto next : getImportSet(dc).getAllImports()) {
222225
// If we found 'mod', record the access path.
223-
if (next.second == mod) {
226+
if (next.importedModule == mod) {
224227
// Make sure the list of access paths is unique.
225-
if (!llvm::is_contained(accessPaths, next.first))
226-
accessPaths.push_back(next.first);
228+
if (!llvm::is_contained(accessPaths, next.accessPath))
229+
accessPaths.push_back(next.accessPath);
227230
}
228231
}
229232

@@ -258,7 +261,8 @@ ImportCache::getAllAccessPathsNotShadowedBy(const ModuleDecl *mod,
258261
SmallVector<ModuleDecl::ImportedModule, 4> stack;
259262
llvm::SmallDenseSet<ModuleDecl::ImportedModule, 32> visited;
260263

261-
stack.emplace_back(ModuleDecl::AccessPathTy(), currentMod);
264+
stack.emplace_back(
265+
ModuleDecl::ImportedModule{ModuleDecl::AccessPathTy(), currentMod});
262266

263267
if (auto *file = dyn_cast<FileUnit>(dc)) {
264268
ModuleDecl::ImportFilter importFilter;
@@ -278,15 +282,15 @@ ImportCache::getAllAccessPathsNotShadowedBy(const ModuleDecl *mod,
278282
continue;
279283

280284
// Don't visit the 'other' module's re-exports.
281-
if (next.second == other)
285+
if (next.importedModule == other)
282286
continue;
283287

284288
// If we found 'mod' via some access path, remember the access
285289
// path.
286-
if (next.second == mod) {
290+
if (next.importedModule == mod) {
287291
// Make sure the list of access paths is unique.
288-
if (!llvm::is_contained(accessPaths, next.first))
289-
accessPaths.push_back(next.first);
292+
if (!llvm::is_contained(accessPaths, next.accessPath))
293+
accessPaths.push_back(next.accessPath);
290294
}
291295

292296
collectExports(next, stack);

‎lib/AST/Module.cpp‎

Lines changed: 31 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -1215,17 +1215,16 @@ lookupOperatorDeclForName(const FileUnit &File, SourceLoc Loc,
12151215
ImportedOperatorsMap<OP_DECL> importedOperators;
12161216
for (auto &imported : SourceFile::Impl::getImportsForSourceFile(SF)) {
12171217
// Protect against source files that contrive to import their own modules.
1218-
if (imported.module.second == ownModule)
1218+
if (imported.module.importedModule == ownModule)
12191219
continue;
12201220

12211221
bool isExported =
12221222
imported.importOptions.contains(SourceFile::ImportFlags::Exported);
12231223
if (!includePrivate && !isExported)
12241224
continue;
12251225

1226-
Optional<OP_DECL *> maybeOp =
1227-
lookupOperatorDeclForName<OP_DECL>(imported.module.second, Loc, Name,
1228-
isCascading);
1226+
Optional<OP_DECL *> maybeOp = lookupOperatorDeclForName<OP_DECL>(
1227+
imported.module.importedModule, Loc, Name, isCascading);
12291228
if (!maybeOp)
12301229
return None;
12311230

@@ -1418,7 +1417,7 @@ SourceFile::getImportedModules(SmallVectorImpl<ModuleDecl::ImportedModule> &modu
14181417
else
14191418
requiredFilter |= ModuleDecl::ImportFilterKind::Private;
14201419

1421-
if (!separatelyImportedOverlays.lookup(desc.module.second).empty())
1420+
if (!separatelyImportedOverlays.lookup(desc.module.importedModule).empty())
14221421
requiredFilter |= ModuleDecl::ImportFilterKind::ShadowedBySeparateOverlay;
14231422

14241423
if (filter.contains(requiredFilter))
@@ -1513,26 +1512,26 @@ ModuleDecl::removeDuplicateImports(SmallVectorImpl<ImportedModule> &imports) {
15131512
std::sort(imports.begin(), imports.end(),
15141513
[](const ImportedModule &lhs, const ImportedModule &rhs) -> bool {
15151514
// Arbitrarily sort by name to get a deterministic order.
1516-
if (lhs.second != rhs.second) {
1515+
if (lhs.importedModule != rhs.importedModule) {
15171516
return std::lexicographical_compare(
1518-
lhs.second->getReverseFullModuleName(), {},
1519-
rhs.second->getReverseFullModuleName(), {});
1517+
lhs.importedModule->getReverseFullModuleName(), {},
1518+
rhs.importedModule->getReverseFullModuleName(), {});
15201519
}
15211520
using AccessPathElem = Located<Identifier>;
1522-
return std::lexicographical_compare(lhs.first.begin(), lhs.first.end(),
1523-
rhs.first.begin(), rhs.first.end(),
1524-
[](const AccessPathElem &lElem,
1525-
const AccessPathElem &rElem) {
1526-
return lElem.Item.str() < rElem.Item.str();
1527-
});
1528-
});
1529-
auto last = std::unique(imports.begin(), imports.end(),
1530-
[](const ImportedModule &lhs,
1531-
const ImportedModule &rhs) -> bool {
1532-
if (lhs.second != rhs.second)
1533-
return false;
1534-
return ModuleDecl::isSameAccessPath(lhs.first, rhs.first);
1521+
return std::lexicographical_compare(
1522+
lhs.accessPath.begin(), lhs.accessPath.end(), rhs.accessPath.begin(),
1523+
rhs.accessPath.end(),
1524+
[](const AccessPathElem &lElem, const AccessPathElem &rElem) {
1525+
return lElem.Item.str() < rElem.Item.str();
1526+
});
15351527
});
1528+
auto last = std::unique(
1529+
imports.begin(), imports.end(),
1530+
[](const ImportedModule &lhs, const ImportedModule &rhs) -> bool {
1531+
if (lhs.importedModule != rhs.importedModule)
1532+
return false;
1533+
return ModuleDecl::isSameAccessPath(lhs.accessPath, rhs.accessPath);
1534+
});
15361535
imports.erase(last, imports.end());
15371536
}
15381537

@@ -1693,11 +1692,12 @@ SourceFile::collectLinkLibraries(ModuleDecl::LinkLibraryCallback callback) const
16931692
topLevel->getImportedModules(stack, topLevelFilter);
16941693

16951694
// Make sure the top-level module is first; we want pre-order-ish traversal.
1696-
stack.emplace_back(ModuleDecl::AccessPathTy(),
1697-
const_cast<ModuleDecl *>(topLevel));
1695+
auto topLevelModule =
1696+
ModuleDecl::ImportedModule{ModuleDecl::AccessPathTy(), topLevel};
1697+
stack.emplace_back(topLevelModule);
16981698

16991699
while (!stack.empty()) {
1700-
auto next = stack.pop_back_val().second;
1700+
auto next = stack.pop_back_val().importedModule;
17011701

17021702
if (!visited.insert(next).second)
17031703
continue;
@@ -1905,7 +1905,7 @@ ModuleDecl::getDeclaringModuleAndBystander() {
19051905

19061906
getImportedModules(imported, ModuleDecl::ImportFilterKind::Public);
19071907
while (!imported.empty()) {
1908-
ModuleDecl *importedModule = std::get<1>(imported.back());
1908+
ModuleDecl *importedModule = imported.back().importedModule;
19091909
imported.pop_back();
19101910
if (!seen.insert(importedModule).second)
19111911
continue;
@@ -2124,15 +2124,15 @@ bool SourceFile::hasTestableOrPrivateImport(
21242124
Imports->begin(), Imports->end(),
21252125
[module, queryKind](ImportedModuleDesc desc) -> bool {
21262126
if (queryKind == ImportQueryKind::TestableAndPrivate)
2127-
return desc.module.second == module &&
2127+
return desc.module.importedModule == module &&
21282128
(desc.importOptions.contains(ImportFlags::PrivateImport) ||
21292129
desc.importOptions.contains(ImportFlags::Testable));
21302130
else if (queryKind == ImportQueryKind::TestableOnly)
2131-
return desc.module.second == module &&
2131+
return desc.module.importedModule == module &&
21322132
desc.importOptions.contains(ImportFlags::Testable);
21332133
else {
21342134
assert(queryKind == ImportQueryKind::PrivateOnly);
2135-
return desc.module.second == module &&
2135+
return desc.module.importedModule == module &&
21362136
desc.importOptions.contains(ImportFlags::PrivateImport);
21372137
}
21382138
});
@@ -2165,7 +2165,7 @@ bool SourceFile::hasTestableOrPrivateImport(
21652165

21662166
return std::any_of(Imports->begin(), Imports->end(),
21672167
[module, filename](ImportedModuleDesc desc) -> bool {
2168-
return desc.module.second == module &&
2168+
return desc.module.importedModule == module &&
21692169
desc.importOptions.contains(
21702170
ImportFlags::PrivateImport) &&
21712171
desc.filename == filename;
@@ -2188,7 +2188,7 @@ bool SourceFile::isImportedImplementationOnly(const ModuleDecl *module) const {
21882188

21892189
// If the module is imported this way, it's not imported
21902190
// implementation-only.
2191-
if (imports.isImportedBy(module, desc.module.second))
2191+
if (imports.isImportedBy(module, desc.module.importedModule))
21922192
return false;
21932193
}
21942194

@@ -2200,7 +2200,7 @@ void SourceFile::lookupImportedSPIGroups(const ModuleDecl *importedModule,
22002200
SmallVectorImpl<Identifier> &spiGroups) const {
22012201
for (auto &import : *Imports) {
22022202
if (import.importOptions.contains(ImportFlags::SPIAccessControl) &&
2203-
importedModule == std::get<ModuleDecl*>(import.module)) {
2203+
importedModule == import.module.importedModule) {
22042204
auto importedSpis = import.spiGroups;
22052205
spiGroups.append(importedSpis.begin(), importedSpis.end());
22062206
}

‎lib/AST/ModuleNameLookup.cpp‎

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -184,13 +184,14 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
184184

185185
auto visitImport = [&](ModuleDecl::ImportedModule import,
186186
const DeclContext *moduleScopeContext) {
187-
if (import.first.empty())
188-
import.first = accessPath;
187+
if (import.accessPath.empty())
188+
import.accessPath = accessPath;
189189
else if (!accessPath.empty() &&
190-
!ModuleDecl::isSameAccessPath(import.first, accessPath))
190+
!ModuleDecl::isSameAccessPath(import.accessPath, accessPath))
191191
return;
192192

193-
getDerived()->doLocalLookup(import.second, import.first, decls);
193+
getDerived()->doLocalLookup(import.importedModule, import.accessPath,
194+
decls);
194195
updateNewDecls(moduleScopeContext);
195196
};
196197

@@ -201,7 +202,8 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
201202
if (auto *loader = ctx.getClangModuleLoader()) {
202203
headerImportModule = loader->getImportedHeaderModule();
203204
if (headerImportModule) {
204-
ModuleDecl::ImportedModule import({}, headerImportModule);
205+
ModuleDecl::ImportedModule import{ModuleDecl::AccessPathTy(),
206+
headerImportModule};
205207
visitImport(import, nullptr);
206208
}
207209
}
@@ -210,19 +212,19 @@ void ModuleNameLookup<LookupStrategy>::lookupInModule(
210212
for (auto import : imports.getTopLevelImports()) {
211213
// A module appears in its own top-level import list; since we checked
212214
// it already, skip it.
213-
if (import.second == module)
215+
if (import.importedModule == module)
214216
continue;
215217

216218
// Skip the special import set module; we've already visited it.
217-
if (import.second == headerImportModule)
219+
if (import.importedModule == headerImportModule)
218220
continue;
219221

220222
visitImport(import, moduleScopeContext);
221223
}
222224

223225
for (auto import : imports.getTransitiveImports()) {
224226
// Skip the special import set module; we've already visited it.
225-
if (import.second == headerImportModule)
227+
if (import.importedModule == headerImportModule)
226228
continue;
227229

228230
visitImport(import, nullptr);

0 commit comments

Comments
 (0)