711 lines
27 KiB
C++
711 lines
27 KiB
C++
//===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements semantic analysis for modules (C++ modules syntax,
|
|
// Objective-C modules syntax, and Clang header modules).
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ASTConsumer.h"
|
|
#include "clang/Lex/HeaderSearch.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Sema/SemaInternal.h"
|
|
|
|
using namespace clang;
|
|
using namespace sema;
|
|
|
|
static void checkModuleImportContext(Sema &S, Module *M,
|
|
SourceLocation ImportLoc, DeclContext *DC,
|
|
bool FromInclude = false) {
|
|
SourceLocation ExternCLoc;
|
|
|
|
if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
|
|
switch (LSD->getLanguage()) {
|
|
case LinkageSpecDecl::lang_c:
|
|
if (ExternCLoc.isInvalid())
|
|
ExternCLoc = LSD->getBeginLoc();
|
|
break;
|
|
case LinkageSpecDecl::lang_cxx:
|
|
break;
|
|
}
|
|
DC = LSD->getParent();
|
|
}
|
|
|
|
while (isa<LinkageSpecDecl>(DC) || isa<ExportDecl>(DC))
|
|
DC = DC->getParent();
|
|
|
|
if (!isa<TranslationUnitDecl>(DC)) {
|
|
S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
|
|
? diag::ext_module_import_not_at_top_level_noop
|
|
: diag::err_module_import_not_at_top_level_fatal)
|
|
<< M->getFullModuleName() << DC;
|
|
S.Diag(cast<Decl>(DC)->getBeginLoc(),
|
|
diag::note_module_import_not_at_top_level)
|
|
<< DC;
|
|
} else if (!M->IsExternC && ExternCLoc.isValid()) {
|
|
S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
|
|
<< M->getFullModuleName();
|
|
S.Diag(ExternCLoc, diag::note_extern_c_begins_here);
|
|
}
|
|
}
|
|
|
|
Sema::DeclGroupPtrTy
|
|
Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
|
|
if (!ModuleScopes.empty() &&
|
|
ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment) {
|
|
// Under -std=c++2a -fmodules-ts, we can find an explicit 'module;' after
|
|
// already implicitly entering the global module fragment. That's OK.
|
|
assert(getLangOpts().CPlusPlusModules && getLangOpts().ModulesTS &&
|
|
"unexpectedly encountered multiple global module fragment decls");
|
|
ModuleScopes.back().BeginLoc = ModuleLoc;
|
|
return nullptr;
|
|
}
|
|
|
|
// We start in the global module; all those declarations are implicitly
|
|
// module-private (though they do not have module linkage).
|
|
auto &Map = PP.getHeaderSearchInfo().getModuleMap();
|
|
auto *GlobalModule = Map.createGlobalModuleFragmentForModuleUnit(ModuleLoc);
|
|
assert(GlobalModule && "module creation should not fail");
|
|
|
|
// Enter the scope of the global module.
|
|
ModuleScopes.push_back({});
|
|
ModuleScopes.back().BeginLoc = ModuleLoc;
|
|
ModuleScopes.back().Module = GlobalModule;
|
|
VisibleModules.setVisible(GlobalModule, ModuleLoc);
|
|
|
|
// All declarations created from now on are owned by the global module.
|
|
auto *TU = Context.getTranslationUnitDecl();
|
|
TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
|
|
TU->setLocalOwningModule(GlobalModule);
|
|
|
|
// FIXME: Consider creating an explicit representation of this declaration.
|
|
return nullptr;
|
|
}
|
|
|
|
Sema::DeclGroupPtrTy
|
|
Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
|
|
ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl) {
|
|
assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&
|
|
"should only have module decl in Modules TS or C++20");
|
|
|
|
// A module implementation unit requires that we are not compiling a module
|
|
// of any kind. A module interface unit requires that we are not compiling a
|
|
// module map.
|
|
switch (getLangOpts().getCompilingModule()) {
|
|
case LangOptions::CMK_None:
|
|
// It's OK to compile a module interface as a normal translation unit.
|
|
break;
|
|
|
|
case LangOptions::CMK_ModuleInterface:
|
|
if (MDK != ModuleDeclKind::Implementation)
|
|
break;
|
|
|
|
// We were asked to compile a module interface unit but this is a module
|
|
// implementation unit. That indicates the 'export' is missing.
|
|
Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)
|
|
<< FixItHint::CreateInsertion(ModuleLoc, "export ");
|
|
MDK = ModuleDeclKind::Interface;
|
|
break;
|
|
|
|
case LangOptions::CMK_ModuleMap:
|
|
Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);
|
|
return nullptr;
|
|
|
|
case LangOptions::CMK_HeaderModule:
|
|
Diag(ModuleLoc, diag::err_module_decl_in_header_module);
|
|
return nullptr;
|
|
}
|
|
|
|
assert(ModuleScopes.size() <= 1 && "expected to be at global module scope");
|
|
|
|
// FIXME: Most of this work should be done by the preprocessor rather than
|
|
// here, in order to support macro import.
|
|
|
|
// Only one module-declaration is permitted per source file.
|
|
if (!ModuleScopes.empty() &&
|
|
ModuleScopes.back().Module->isModulePurview()) {
|
|
Diag(ModuleLoc, diag::err_module_redeclaration);
|
|
Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),
|
|
diag::note_prev_module_declaration);
|
|
return nullptr;
|
|
}
|
|
|
|
// Find the global module fragment we're adopting into this module, if any.
|
|
Module *GlobalModuleFragment = nullptr;
|
|
if (!ModuleScopes.empty() &&
|
|
ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment)
|
|
GlobalModuleFragment = ModuleScopes.back().Module;
|
|
|
|
// In C++20, the module-declaration must be the first declaration if there
|
|
// is no global module fragment.
|
|
if (getLangOpts().CPlusPlusModules && !IsFirstDecl && !GlobalModuleFragment) {
|
|
Diag(ModuleLoc, diag::err_module_decl_not_at_start);
|
|
SourceLocation BeginLoc =
|
|
ModuleScopes.empty()
|
|
? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
|
|
: ModuleScopes.back().BeginLoc;
|
|
if (BeginLoc.isValid()) {
|
|
Diag(BeginLoc, diag::note_global_module_introducer_missing)
|
|
<< FixItHint::CreateInsertion(BeginLoc, "module;\n");
|
|
}
|
|
}
|
|
|
|
// Flatten the dots in a module name. Unlike Clang's hierarchical module map
|
|
// modules, the dots here are just another character that can appear in a
|
|
// module name.
|
|
std::string ModuleName;
|
|
for (auto &Piece : Path) {
|
|
if (!ModuleName.empty())
|
|
ModuleName += ".";
|
|
ModuleName += Piece.first->getName();
|
|
}
|
|
|
|
// If a module name was explicitly specified on the command line, it must be
|
|
// correct.
|
|
if (!getLangOpts().CurrentModule.empty() &&
|
|
getLangOpts().CurrentModule != ModuleName) {
|
|
Diag(Path.front().second, diag::err_current_module_name_mismatch)
|
|
<< SourceRange(Path.front().second, Path.back().second)
|
|
<< getLangOpts().CurrentModule;
|
|
return nullptr;
|
|
}
|
|
const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
|
|
|
|
auto &Map = PP.getHeaderSearchInfo().getModuleMap();
|
|
Module *Mod;
|
|
|
|
switch (MDK) {
|
|
case ModuleDeclKind::Interface: {
|
|
// We can't have parsed or imported a definition of this module or parsed a
|
|
// module map defining it already.
|
|
if (auto *M = Map.findModule(ModuleName)) {
|
|
Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
|
|
if (M->DefinitionLoc.isValid())
|
|
Diag(M->DefinitionLoc, diag::note_prev_module_definition);
|
|
else if (Optional<FileEntryRef> FE = M->getASTFile())
|
|
Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
|
|
<< FE->getName();
|
|
Mod = M;
|
|
break;
|
|
}
|
|
|
|
// Create a Module for the module that we're defining.
|
|
Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
|
|
GlobalModuleFragment);
|
|
assert(Mod && "module creation should not fail");
|
|
break;
|
|
}
|
|
|
|
case ModuleDeclKind::Implementation:
|
|
std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
|
|
PP.getIdentifierInfo(ModuleName), Path[0].second);
|
|
Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
|
|
Module::AllVisible,
|
|
/*IsInclusionDirective=*/false);
|
|
if (!Mod) {
|
|
Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;
|
|
// Create an empty module interface unit for error recovery.
|
|
Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
|
|
GlobalModuleFragment);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!GlobalModuleFragment) {
|
|
ModuleScopes.push_back({});
|
|
if (getLangOpts().ModulesLocalVisibility)
|
|
ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
|
|
} else {
|
|
// We're done with the global module fragment now.
|
|
ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);
|
|
}
|
|
|
|
// Switch from the global module fragment (if any) to the named module.
|
|
ModuleScopes.back().BeginLoc = StartLoc;
|
|
ModuleScopes.back().Module = Mod;
|
|
ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
|
|
VisibleModules.setVisible(Mod, ModuleLoc);
|
|
|
|
// From now on, we have an owning module for all declarations we see.
|
|
// However, those declarations are module-private unless explicitly
|
|
// exported.
|
|
auto *TU = Context.getTranslationUnitDecl();
|
|
TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
|
|
TU->setLocalOwningModule(Mod);
|
|
|
|
// FIXME: Create a ModuleDecl.
|
|
return nullptr;
|
|
}
|
|
|
|
Sema::DeclGroupPtrTy
|
|
Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
|
|
SourceLocation PrivateLoc) {
|
|
// C++20 [basic.link]/2:
|
|
// A private-module-fragment shall appear only in a primary module
|
|
// interface unit.
|
|
switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
|
|
: ModuleScopes.back().Module->Kind) {
|
|
case Module::ModuleMapModule:
|
|
case Module::GlobalModuleFragment:
|
|
Diag(PrivateLoc, diag::err_private_module_fragment_not_module);
|
|
return nullptr;
|
|
|
|
case Module::PrivateModuleFragment:
|
|
Diag(PrivateLoc, diag::err_private_module_fragment_redefined);
|
|
Diag(ModuleScopes.back().BeginLoc, diag::note_previous_definition);
|
|
return nullptr;
|
|
|
|
case Module::ModuleInterfaceUnit:
|
|
break;
|
|
}
|
|
|
|
if (!ModuleScopes.back().ModuleInterface) {
|
|
Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);
|
|
Diag(ModuleScopes.back().BeginLoc,
|
|
diag::note_not_module_interface_add_export)
|
|
<< FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
|
|
return nullptr;
|
|
}
|
|
|
|
// FIXME: Check this isn't a module interface partition.
|
|
// FIXME: Check that this translation unit does not import any partitions;
|
|
// such imports would violate [basic.link]/2's "shall be the only module unit"
|
|
// restriction.
|
|
|
|
// We've finished the public fragment of the translation unit.
|
|
ActOnEndOfTranslationUnitFragment(TUFragmentKind::Normal);
|
|
|
|
auto &Map = PP.getHeaderSearchInfo().getModuleMap();
|
|
Module *PrivateModuleFragment =
|
|
Map.createPrivateModuleFragmentForInterfaceUnit(
|
|
ModuleScopes.back().Module, PrivateLoc);
|
|
assert(PrivateModuleFragment && "module creation should not fail");
|
|
|
|
// Enter the scope of the private module fragment.
|
|
ModuleScopes.push_back({});
|
|
ModuleScopes.back().BeginLoc = ModuleLoc;
|
|
ModuleScopes.back().Module = PrivateModuleFragment;
|
|
ModuleScopes.back().ModuleInterface = true;
|
|
VisibleModules.setVisible(PrivateModuleFragment, ModuleLoc);
|
|
|
|
// All declarations created from now on are scoped to the private module
|
|
// fragment (and are neither visible nor reachable in importers of the module
|
|
// interface).
|
|
auto *TU = Context.getTranslationUnitDecl();
|
|
TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
|
|
TU->setLocalOwningModule(PrivateModuleFragment);
|
|
|
|
// FIXME: Consider creating an explicit representation of this declaration.
|
|
return nullptr;
|
|
}
|
|
|
|
DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
|
|
SourceLocation ExportLoc,
|
|
SourceLocation ImportLoc,
|
|
ModuleIdPath Path) {
|
|
// Flatten the module path for a Modules TS module name.
|
|
std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
|
|
if (getLangOpts().ModulesTS) {
|
|
std::string ModuleName;
|
|
for (auto &Piece : Path) {
|
|
if (!ModuleName.empty())
|
|
ModuleName += ".";
|
|
ModuleName += Piece.first->getName();
|
|
}
|
|
ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
|
|
Path = ModuleIdPath(ModuleNameLoc);
|
|
}
|
|
|
|
Module *Mod =
|
|
getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
|
|
/*IsInclusionDirective=*/false);
|
|
if (!Mod)
|
|
return true;
|
|
|
|
return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path);
|
|
}
|
|
|
|
/// Determine whether \p D is lexically within an export-declaration.
|
|
static const ExportDecl *getEnclosingExportDecl(const Decl *D) {
|
|
for (auto *DC = D->getLexicalDeclContext(); DC; DC = DC->getLexicalParent())
|
|
if (auto *ED = dyn_cast<ExportDecl>(DC))
|
|
return ED;
|
|
return nullptr;
|
|
}
|
|
|
|
DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
|
|
SourceLocation ExportLoc,
|
|
SourceLocation ImportLoc,
|
|
Module *Mod, ModuleIdPath Path) {
|
|
VisibleModules.setVisible(Mod, ImportLoc);
|
|
|
|
checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
|
|
|
|
// FIXME: we should support importing a submodule within a different submodule
|
|
// of the same top-level module. Until we do, make it an error rather than
|
|
// silently ignoring the import.
|
|
// Import-from-implementation is valid in the Modules TS. FIXME: Should we
|
|
// warn on a redundant import of the current module?
|
|
// FIXME: Import of a module from an implementation partition of the same
|
|
// module is permitted.
|
|
if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
|
|
(getLangOpts().isCompilingModule() || !getLangOpts().ModulesTS)) {
|
|
Diag(ImportLoc, getLangOpts().isCompilingModule()
|
|
? diag::err_module_self_import
|
|
: diag::err_module_import_in_implementation)
|
|
<< Mod->getFullModuleName() << getLangOpts().CurrentModule;
|
|
}
|
|
|
|
SmallVector<SourceLocation, 2> IdentifierLocs;
|
|
Module *ModCheck = Mod;
|
|
for (unsigned I = 0, N = Path.size(); I != N; ++I) {
|
|
// If we've run out of module parents, just drop the remaining identifiers.
|
|
// We need the length to be consistent.
|
|
if (!ModCheck)
|
|
break;
|
|
ModCheck = ModCheck->Parent;
|
|
|
|
IdentifierLocs.push_back(Path[I].second);
|
|
}
|
|
|
|
// If this was a header import, pad out with dummy locations.
|
|
// FIXME: Pass in and use the location of the header-name token in this case.
|
|
if (Path.empty()) {
|
|
for (; ModCheck; ModCheck = ModCheck->Parent) {
|
|
IdentifierLocs.push_back(SourceLocation());
|
|
}
|
|
}
|
|
|
|
ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,
|
|
Mod, IdentifierLocs);
|
|
CurContext->addDecl(Import);
|
|
|
|
// Sequence initialization of the imported module before that of the current
|
|
// module, if any.
|
|
if (!ModuleScopes.empty())
|
|
Context.addModuleInitializer(ModuleScopes.back().Module, Import);
|
|
|
|
// Re-export the module if needed.
|
|
if (!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface) {
|
|
if (ExportLoc.isValid() || getEnclosingExportDecl(Import))
|
|
getCurrentModule()->Exports.emplace_back(Mod, false);
|
|
} else if (ExportLoc.isValid()) {
|
|
Diag(ExportLoc, diag::err_export_not_in_module_interface);
|
|
}
|
|
|
|
return Import;
|
|
}
|
|
|
|
void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
|
|
checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
|
|
BuildModuleInclude(DirectiveLoc, Mod);
|
|
}
|
|
|
|
void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
|
|
// Determine whether we're in the #include buffer for a module. The #includes
|
|
// in that buffer do not qualify as module imports; they're just an
|
|
// implementation detail of us building the module.
|
|
//
|
|
// FIXME: Should we even get ActOnModuleInclude calls for those?
|
|
bool IsInModuleIncludes =
|
|
TUKind == TU_Module &&
|
|
getSourceManager().isWrittenInMainFile(DirectiveLoc);
|
|
|
|
bool ShouldAddImport = !IsInModuleIncludes;
|
|
|
|
// If this module import was due to an inclusion directive, create an
|
|
// implicit import declaration to capture it in the AST.
|
|
if (ShouldAddImport) {
|
|
TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
|
|
ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
|
|
DirectiveLoc, Mod,
|
|
DirectiveLoc);
|
|
if (!ModuleScopes.empty())
|
|
Context.addModuleInitializer(ModuleScopes.back().Module, ImportD);
|
|
TU->addDecl(ImportD);
|
|
Consumer.HandleImplicitImportDecl(ImportD);
|
|
}
|
|
|
|
getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
|
|
VisibleModules.setVisible(Mod, DirectiveLoc);
|
|
}
|
|
|
|
void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
|
|
checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
|
|
|
|
ModuleScopes.push_back({});
|
|
ModuleScopes.back().Module = Mod;
|
|
if (getLangOpts().ModulesLocalVisibility)
|
|
ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
|
|
|
|
VisibleModules.setVisible(Mod, DirectiveLoc);
|
|
|
|
// The enclosing context is now part of this module.
|
|
// FIXME: Consider creating a child DeclContext to hold the entities
|
|
// lexically within the module.
|
|
if (getLangOpts().trackLocalOwningModule()) {
|
|
for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
|
|
cast<Decl>(DC)->setModuleOwnershipKind(
|
|
getLangOpts().ModulesLocalVisibility
|
|
? Decl::ModuleOwnershipKind::VisibleWhenImported
|
|
: Decl::ModuleOwnershipKind::Visible);
|
|
cast<Decl>(DC)->setLocalOwningModule(Mod);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Sema::ActOnModuleEnd(SourceLocation EomLoc, Module *Mod) {
|
|
if (getLangOpts().ModulesLocalVisibility) {
|
|
VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
|
|
// Leaving a module hides namespace names, so our visible namespace cache
|
|
// is now out of date.
|
|
VisibleNamespaceCache.clear();
|
|
}
|
|
|
|
assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
|
|
"left the wrong module scope");
|
|
ModuleScopes.pop_back();
|
|
|
|
// We got to the end of processing a local module. Create an
|
|
// ImportDecl as we would for an imported module.
|
|
FileID File = getSourceManager().getFileID(EomLoc);
|
|
SourceLocation DirectiveLoc;
|
|
if (EomLoc == getSourceManager().getLocForEndOfFile(File)) {
|
|
// We reached the end of a #included module header. Use the #include loc.
|
|
assert(File != getSourceManager().getMainFileID() &&
|
|
"end of submodule in main source file");
|
|
DirectiveLoc = getSourceManager().getIncludeLoc(File);
|
|
} else {
|
|
// We reached an EOM pragma. Use the pragma location.
|
|
DirectiveLoc = EomLoc;
|
|
}
|
|
BuildModuleInclude(DirectiveLoc, Mod);
|
|
|
|
// Any further declarations are in whatever module we returned to.
|
|
if (getLangOpts().trackLocalOwningModule()) {
|
|
// The parser guarantees that this is the same context that we entered
|
|
// the module within.
|
|
for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
|
|
cast<Decl>(DC)->setLocalOwningModule(getCurrentModule());
|
|
if (!getCurrentModule())
|
|
cast<Decl>(DC)->setModuleOwnershipKind(
|
|
Decl::ModuleOwnershipKind::Unowned);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
|
|
Module *Mod) {
|
|
// Bail if we're not allowed to implicitly import a module here.
|
|
if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery ||
|
|
VisibleModules.isVisible(Mod))
|
|
return;
|
|
|
|
// Create the implicit import declaration.
|
|
TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
|
|
ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
|
|
Loc, Mod, Loc);
|
|
TU->addDecl(ImportD);
|
|
Consumer.HandleImplicitImportDecl(ImportD);
|
|
|
|
// Make the module visible.
|
|
getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
|
|
VisibleModules.setVisible(Mod, Loc);
|
|
}
|
|
|
|
/// We have parsed the start of an export declaration, including the '{'
|
|
/// (if present).
|
|
Decl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
|
|
SourceLocation LBraceLoc) {
|
|
ExportDecl *D = ExportDecl::Create(Context, CurContext, ExportLoc);
|
|
|
|
// Set this temporarily so we know the export-declaration was braced.
|
|
D->setRBraceLoc(LBraceLoc);
|
|
|
|
// C++2a [module.interface]p1:
|
|
// An export-declaration shall appear only [...] in the purview of a module
|
|
// interface unit. An export-declaration shall not appear directly or
|
|
// indirectly within [...] a private-module-fragment.
|
|
if (ModuleScopes.empty() || !ModuleScopes.back().Module->isModulePurview()) {
|
|
Diag(ExportLoc, diag::err_export_not_in_module_interface) << 0;
|
|
} else if (!ModuleScopes.back().ModuleInterface) {
|
|
Diag(ExportLoc, diag::err_export_not_in_module_interface) << 1;
|
|
Diag(ModuleScopes.back().BeginLoc,
|
|
diag::note_not_module_interface_add_export)
|
|
<< FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
|
|
} else if (ModuleScopes.back().Module->Kind ==
|
|
Module::PrivateModuleFragment) {
|
|
Diag(ExportLoc, diag::err_export_in_private_module_fragment);
|
|
Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);
|
|
}
|
|
|
|
for (const DeclContext *DC = CurContext; DC; DC = DC->getLexicalParent()) {
|
|
if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
|
|
// An export-declaration shall not appear directly or indirectly within
|
|
// an unnamed namespace [...]
|
|
if (ND->isAnonymousNamespace()) {
|
|
Diag(ExportLoc, diag::err_export_within_anonymous_namespace);
|
|
Diag(ND->getLocation(), diag::note_anonymous_namespace);
|
|
// Don't diagnose internal-linkage declarations in this region.
|
|
D->setInvalidDecl();
|
|
break;
|
|
}
|
|
|
|
// A declaration is exported if it is [...] a namespace-definition
|
|
// that contains an exported declaration.
|
|
//
|
|
// Defer exporting the namespace until after we leave it, in order to
|
|
// avoid marking all subsequent declarations in the namespace as exported.
|
|
if (!DeferredExportedNamespaces.insert(ND).second)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// [...] its declaration or declaration-seq shall not contain an
|
|
// export-declaration.
|
|
if (auto *ED = getEnclosingExportDecl(D)) {
|
|
Diag(ExportLoc, diag::err_export_within_export);
|
|
if (ED->hasBraces())
|
|
Diag(ED->getLocation(), diag::note_export);
|
|
}
|
|
|
|
CurContext->addDecl(D);
|
|
PushDeclContext(S, D);
|
|
D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
|
|
return D;
|
|
}
|
|
|
|
static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
|
|
SourceLocation BlockStart);
|
|
|
|
namespace {
|
|
enum class UnnamedDeclKind {
|
|
Empty,
|
|
StaticAssert,
|
|
Asm,
|
|
UsingDirective,
|
|
Context
|
|
};
|
|
}
|
|
|
|
static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {
|
|
if (isa<EmptyDecl>(D))
|
|
return UnnamedDeclKind::Empty;
|
|
if (isa<StaticAssertDecl>(D))
|
|
return UnnamedDeclKind::StaticAssert;
|
|
if (isa<FileScopeAsmDecl>(D))
|
|
return UnnamedDeclKind::Asm;
|
|
if (isa<UsingDirectiveDecl>(D))
|
|
return UnnamedDeclKind::UsingDirective;
|
|
// Everything else either introduces one or more names or is ill-formed.
|
|
return llvm::None;
|
|
}
|
|
|
|
unsigned getUnnamedDeclDiag(UnnamedDeclKind UDK, bool InBlock) {
|
|
switch (UDK) {
|
|
case UnnamedDeclKind::Empty:
|
|
case UnnamedDeclKind::StaticAssert:
|
|
// Allow empty-declarations and static_asserts in an export block as an
|
|
// extension.
|
|
return InBlock ? diag::ext_export_no_name_block : diag::err_export_no_name;
|
|
|
|
case UnnamedDeclKind::UsingDirective:
|
|
// Allow exporting using-directives as an extension.
|
|
return diag::ext_export_using_directive;
|
|
|
|
case UnnamedDeclKind::Context:
|
|
// Allow exporting DeclContexts that transitively contain no declarations
|
|
// as an extension.
|
|
return diag::ext_export_no_names;
|
|
|
|
case UnnamedDeclKind::Asm:
|
|
return diag::err_export_no_name;
|
|
}
|
|
llvm_unreachable("unknown kind");
|
|
}
|
|
|
|
static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D,
|
|
SourceLocation BlockStart) {
|
|
S.Diag(D->getLocation(), getUnnamedDeclDiag(UDK, BlockStart.isValid()))
|
|
<< (unsigned)UDK;
|
|
if (BlockStart.isValid())
|
|
S.Diag(BlockStart, diag::note_export);
|
|
}
|
|
|
|
/// Check that it's valid to export \p D.
|
|
static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {
|
|
// C++2a [module.interface]p3:
|
|
// An exported declaration shall declare at least one name
|
|
if (auto UDK = getUnnamedDeclKind(D))
|
|
diagExportedUnnamedDecl(S, *UDK, D, BlockStart);
|
|
|
|
// [...] shall not declare a name with internal linkage.
|
|
if (auto *ND = dyn_cast<NamedDecl>(D)) {
|
|
// Don't diagnose anonymous union objects; we'll diagnose their members
|
|
// instead.
|
|
if (ND->getDeclName() && ND->getFormalLinkage() == InternalLinkage) {
|
|
S.Diag(ND->getLocation(), diag::err_export_internal) << ND;
|
|
if (BlockStart.isValid())
|
|
S.Diag(BlockStart, diag::note_export);
|
|
}
|
|
}
|
|
|
|
// C++2a [module.interface]p5:
|
|
// all entities to which all of the using-declarators ultimately refer
|
|
// shall have been introduced with a name having external linkage
|
|
if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
|
|
NamedDecl *Target = USD->getUnderlyingDecl();
|
|
if (Target->getFormalLinkage() == InternalLinkage) {
|
|
S.Diag(USD->getLocation(), diag::err_export_using_internal) << Target;
|
|
S.Diag(Target->getLocation(), diag::note_using_decl_target);
|
|
if (BlockStart.isValid())
|
|
S.Diag(BlockStart, diag::note_export);
|
|
}
|
|
}
|
|
|
|
// Recurse into namespace-scope DeclContexts. (Only namespace-scope
|
|
// declarations are exported.)
|
|
if (auto *DC = dyn_cast<DeclContext>(D))
|
|
if (DC->getRedeclContext()->isFileContext() && !isa<EnumDecl>(D))
|
|
return checkExportedDeclContext(S, DC, BlockStart);
|
|
return false;
|
|
}
|
|
|
|
/// Check that it's valid to export all the declarations in \p DC.
|
|
static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
|
|
SourceLocation BlockStart) {
|
|
bool AllUnnamed = true;
|
|
for (auto *D : DC->decls())
|
|
AllUnnamed &= checkExportedDecl(S, D, BlockStart);
|
|
return AllUnnamed;
|
|
}
|
|
|
|
/// Complete the definition of an export declaration.
|
|
Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {
|
|
auto *ED = cast<ExportDecl>(D);
|
|
if (RBraceLoc.isValid())
|
|
ED->setRBraceLoc(RBraceLoc);
|
|
|
|
PopDeclContext();
|
|
|
|
if (!D->isInvalidDecl()) {
|
|
SourceLocation BlockStart =
|
|
ED->hasBraces() ? ED->getBeginLoc() : SourceLocation();
|
|
for (auto *Child : ED->decls()) {
|
|
if (checkExportedDecl(*this, Child, BlockStart)) {
|
|
// If a top-level child is a linkage-spec declaration, it might contain
|
|
// no declarations (transitively), in which case it's ill-formed.
|
|
diagExportedUnnamedDecl(*this, UnnamedDeclKind::Context, Child,
|
|
BlockStart);
|
|
}
|
|
}
|
|
}
|
|
|
|
return D;
|
|
}
|