Skip to content

Commit c489fff

Browse files
beccadaxbeccadax
committed
[NFC] Rename and document fields of AttributedImport
Also renames a member in ImportResolution.cpp to align with this naming.
1 parent f3d99ce commit c489fff

File tree

5 files changed

+43
-37
lines changed

5 files changed

+43
-37
lines changed

Diff for: ‎include/swift/AST/Import.h

+18-12
Original file line numberDiff line numberDiff line change
@@ -444,25 +444,31 @@ struct alignas(uint64_t) ImportedModule {
444444
};
445445
};
446446

447+
/// Augments a type representing an import to also include information about the
448+
/// import's attributes. This is usually used with either \c ImportedModule or
449+
/// \c UnloadedImportedModule.
447450
template<class ModuleInfo>
448451
struct AttributedImport {
452+
/// Information about the module and access path being imported.
449453
ModuleInfo module;
450454

451-
ImportOptions importOptions;
455+
/// Flags indicating which attributes of this import are present.
456+
ImportOptions options;
452457

453-
// Filename for a @_private import.
454-
StringRef filename;
458+
/// If this is a @_private import, the value of its 'sourceFile:' argument;
459+
/// otherwise, empty string.
460+
StringRef sourceFileArg;
455461

456-
// Names of explicitly imported SPIs.
462+
/// Names of explicitly imported SPI groups.
457463
ArrayRef<Identifier> spiGroups;
458464

459465
AttributedImport(ModuleInfo module, ImportOptions options,
460466
StringRef filename = {}, ArrayRef<Identifier> spiGroups = {})
461-
: module(module), importOptions(options), filename(filename),
467+
: module(module), options(options), sourceFileArg(filename),
462468
spiGroups(spiGroups) {
463-
assert(!(importOptions.contains(ImportFlags::Exported) &&
464-
importOptions.contains(ImportFlags::ImplementationOnly)) ||
465-
importOptions.contains(ImportFlags::Reserved));
469+
assert(!(options.contains(ImportFlags::Exported) &&
470+
options.contains(ImportFlags::ImplementationOnly)) ||
471+
options.contains(ImportFlags::Reserved));
466472
}
467473
};
468474

@@ -596,14 +602,14 @@ struct DenseMapInfo<swift::AttributedImport<ModuleInfo>> {
596602
return detail::combineHashValue(
597603
ModuleInfoDMI::getHashValue(import.module),
598604
detail::combineHashValue(
599-
ImportOptionsDMI::getHashValue(import.importOptions),
600-
StringRefDMI::getHashValue(import.filename)));
605+
ImportOptionsDMI::getHashValue(import.options),
606+
StringRefDMI::getHashValue(import.sourceFileArg)));
601607
}
602608
static bool isEqual(const AttributedImport &a,
603609
const AttributedImport &b) {
604610
return ModuleInfoDMI::isEqual(a.module, b.module) &&
605-
ImportOptionsDMI::isEqual(a.importOptions, b.importOptions) &&
606-
StringRefDMI::isEqual(a.filename, b.filename);
611+
ImportOptionsDMI::isEqual(a.options, b.options) &&
612+
StringRefDMI::isEqual(a.sourceFileArg, b.sourceFileArg);
607613
}
608614
};
609615
}

Diff for: ‎lib/AST/Module.cpp

+12-12
Original file line numberDiff line numberDiff line change
@@ -1191,14 +1191,14 @@ SourceFile::getImportedModules(SmallVectorImpl<ImportedModule> &modules,
11911191

11921192
for (auto desc : *Imports) {
11931193
ModuleDecl::ImportFilter requiredFilter;
1194-
if (desc.importOptions.contains(ImportFlags::Exported))
1194+
if (desc.options.contains(ImportFlags::Exported))
11951195
requiredFilter |= ModuleDecl::ImportFilterKind::Exported;
1196-
else if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
1196+
else if (desc.options.contains(ImportFlags::ImplementationOnly))
11971197
requiredFilter |= ModuleDecl::ImportFilterKind::ImplementationOnly;
11981198
else
11991199
requiredFilter |= ModuleDecl::ImportFilterKind::Default;
12001200

1201-
if (desc.importOptions.contains(ImportFlags::SPIAccessControl))
1201+
if (desc.options.contains(ImportFlags::SPIAccessControl))
12021202
requiredFilter |= ModuleDecl::ImportFilterKind::SPIAccessControl;
12031203

12041204
if (!separatelyImportedOverlays.lookup(desc.module.importedModule).empty())
@@ -1892,7 +1892,7 @@ bool HasImplementationOnlyImportsRequest::evaluate(Evaluator &evaluator,
18921892
SourceFile *SF) const {
18931893
return llvm::any_of(SF->getImports(),
18941894
[](AttributedImport<ImportedModule> desc) {
1895-
return desc.importOptions.contains(ImportFlags::ImplementationOnly);
1895+
return desc.options.contains(ImportFlags::ImplementationOnly);
18961896
});
18971897
}
18981898

@@ -1917,15 +1917,15 @@ bool SourceFile::hasTestableOrPrivateImport(
19171917
[module, queryKind](AttributedImport<ImportedModule> desc) -> bool {
19181918
if (queryKind == ImportQueryKind::TestableAndPrivate)
19191919
return desc.module.importedModule == module &&
1920-
(desc.importOptions.contains(ImportFlags::PrivateImport) ||
1921-
desc.importOptions.contains(ImportFlags::Testable));
1920+
(desc.options.contains(ImportFlags::PrivateImport) ||
1921+
desc.options.contains(ImportFlags::Testable));
19221922
else if (queryKind == ImportQueryKind::TestableOnly)
19231923
return desc.module.importedModule == module &&
1924-
desc.importOptions.contains(ImportFlags::Testable);
1924+
desc.options.contains(ImportFlags::Testable);
19251925
else {
19261926
assert(queryKind == ImportQueryKind::PrivateOnly);
19271927
return desc.module.importedModule == module &&
1928-
desc.importOptions.contains(ImportFlags::PrivateImport);
1928+
desc.options.contains(ImportFlags::PrivateImport);
19291929
}
19301930
});
19311931
case AccessLevel::Open:
@@ -1958,8 +1958,8 @@ bool SourceFile::hasTestableOrPrivateImport(
19581958
return llvm::any_of(*Imports,
19591959
[module, filename](AttributedImport<ImportedModule> desc) {
19601960
return desc.module.importedModule == module &&
1961-
desc.importOptions.contains(ImportFlags::PrivateImport) &&
1962-
desc.filename == filename;
1961+
desc.options.contains(ImportFlags::PrivateImport) &&
1962+
desc.sourceFileArg == filename;
19631963
});
19641964
}
19651965

@@ -1974,7 +1974,7 @@ bool SourceFile::isImportedImplementationOnly(const ModuleDecl *module) const {
19741974
// Look at the imports of this source file.
19751975
for (auto &desc : *Imports) {
19761976
// Ignore implementation-only imports.
1977-
if (desc.importOptions.contains(ImportFlags::ImplementationOnly))
1977+
if (desc.options.contains(ImportFlags::ImplementationOnly))
19781978
continue;
19791979

19801980
// If the module is imported this way, it's not imported
@@ -2012,7 +2012,7 @@ void SourceFile::lookupImportedSPIGroups(
20122012
const ModuleDecl *importedModule,
20132013
llvm::SmallSetVector<Identifier, 4> &spiGroups) const {
20142014
for (auto &import : *Imports) {
2015-
if (import.importOptions.contains(ImportFlags::SPIAccessControl) &&
2015+
if (import.options.contains(ImportFlags::SPIAccessControl) &&
20162016
importedModule == import.module.importedModule) {
20172017
auto importedSpis = import.spiGroups;
20182018
spiGroups.insert(importedSpis.begin(), importedSpis.end());

Diff for: ‎lib/AST/NameLookup.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -290,7 +290,7 @@ static void recordShadowedDeclsAfterTypeMatch(
290290
auto file = dc->getParentSourceFile();
291291
if (!file) return false;
292292
for (const auto &import : file->getImports()) {
293-
if (import.importOptions.contains(ImportFlags::PrivateImport)
293+
if (import.options.contains(ImportFlags::PrivateImport)
294294
&& import.module.importedModule == module
295295
&& import.module.accessPath.matches(name))
296296
return true;

Diff for: ‎lib/AST/OperatorNameLookup.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ static TinyPtrVector<T *> lookupOperatorImpl(
8383
if (!visitedModules.insert(mod).second)
8484
continue;
8585

86-
bool isExported = import.importOptions.contains(ImportFlags::Exported);
86+
bool isExported = import.options.contains(ImportFlags::Exported);
8787
if (!includePrivate && !isExported)
8888
continue;
8989

Diff for: ‎lib/Sema/ImportResolution.cpp

+11-11
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ struct UnboundImport {
6161

6262
/// If \c options includes \c PrivateImport, the filename we should import
6363
/// private declarations from.
64-
StringRef privateImportFileName;
64+
StringRef sourceFileArg;
6565

6666
/// The module names being imported. There will usually be just one for the
6767
/// top-level module, but a submodule import will have more.
@@ -137,8 +137,8 @@ struct UnboundImport {
137137
/// UnboundImport.
138138
AttributedImport<ImportedModule>
139139
makeAttributedImport(ModuleDecl *module) const {
140-
return AttributedImport<ImportedModule>({ accessPath, module }, options,
141-
privateImportFileName, spiGroups);
140+
return { ImportedModule{ accessPath, module },
141+
options, sourceFileArg, spiGroups };
142142
}
143143

144144
private:
@@ -496,7 +496,7 @@ ModuleImplicitImportsRequest::evaluate(Evaluator &evaluator,
496496

497497
/// Create an UnboundImport for a user-written import declaration.
498498
UnboundImport::UnboundImport(ImportDecl *ID)
499-
: importLoc(ID->getLoc()), options(), privateImportFileName(),
499+
: importLoc(ID->getLoc()), options(), sourceFileArg(),
500500
modulePath(ID->getModulePath()), accessPath(ID->getAccessPath()),
501501
importOrUnderlyingModuleDecl(ID)
502502
{
@@ -512,7 +512,7 @@ UnboundImport::UnboundImport(ImportDecl *ID)
512512
if (auto *privateImportAttr =
513513
ID->getAttrs().getAttribute<PrivateImportAttr>()) {
514514
options |= ImportFlags::PrivateImport;
515-
privateImportFileName = privateImportAttr->getSourceFile();
515+
sourceFileArg = privateImportAttr->getSourceFile();
516516
}
517517

518518
SmallVector<Identifier, 4> spiGroups;
@@ -607,7 +607,7 @@ void UnboundImport::validatePrivate(ModuleDecl *topLevelModule) {
607607

608608
diagnoseInvalidAttr(DAK_PrivateImport, ctx.Diags,
609609
diag::module_not_compiled_for_private_import);
610-
privateImportFileName = StringRef();
610+
sourceFileArg = StringRef();
611611
}
612612

613613
void UnboundImport::validateImplementationOnly(ASTContext &ctx) {
@@ -915,9 +915,9 @@ ScopedImportLookupRequest::evaluate(Evaluator &evaluator,
915915
//===----------------------------------------------------------------------===//
916916

917917
static bool canCrossImport(const AttributedImport<ImportedModule> &import) {
918-
if (import.importOptions.contains(ImportFlags::Testable))
918+
if (import.options.contains(ImportFlags::Testable))
919919
return false;
920-
if (import.importOptions.contains(ImportFlags::PrivateImport))
920+
if (import.options.contains(ImportFlags::PrivateImport))
921921
return false;
922922

923923
return true;
@@ -928,7 +928,7 @@ UnboundImport::UnboundImport(
928928
ASTContext &ctx, const UnboundImport &base, Identifier overlayName,
929929
const AttributedImport<ImportedModule> &declaringImport,
930930
const AttributedImport<ImportedModule> &bystandingImport)
931-
: importLoc(base.importLoc), options(), privateImportFileName(),
931+
: importLoc(base.importLoc), options(), sourceFileArg(),
932932
// Cross-imports are not backed by an ImportDecl, so we need to provide
933933
// our own storage for their module paths.
934934
modulePath(
@@ -944,8 +944,8 @@ UnboundImport::UnboundImport(
944944
assert(canCrossImport(declaringImport));
945945
assert(canCrossImport(bystandingImport));
946946

947-
auto &declaringOptions = declaringImport.importOptions;
948-
auto &bystandingOptions = bystandingImport.importOptions;
947+
auto &declaringOptions = declaringImport.options;
948+
auto &bystandingOptions = bystandingImport.options;
949949

950950
// If both are exported, the cross-import is exported.
951951
if (declaringOptions.contains(ImportFlags::Exported) &&

0 commit comments

Comments
 (0)