clang 10.0.0git

SemaModule.cpp
Go to the documentation of this file.
1 //===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements semantic analysis for modules (C++ modules syntax,
10 // Objective-C modules syntax, and Clang header modules).
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/Lex/HeaderSearch.h"
16 #include "clang/Lex/Preprocessor.h"
17 #include "clang/Sema/SemaInternal.h"
18
19 using namespace clang;
20 using namespace sema;
21
22 static void checkModuleImportContext(Sema &S, Module *M,
23 SourceLocation ImportLoc, DeclContext *DC,
24 bool FromInclude = false) {
25 SourceLocation ExternCLoc;
26
27 if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
28 switch (LSD->getLanguage()) {
29 case LinkageSpecDecl::lang_c:
30 if (ExternCLoc.isInvalid())
31 ExternCLoc = LSD->getBeginLoc();
32 break;
33 case LinkageSpecDecl::lang_cxx:
34 break;
35 }
36 DC = LSD->getParent();
37 }
38
39 while (isa<LinkageSpecDecl>(DC) || isa<ExportDecl>(DC))
40 DC = DC->getParent();
41
42 if (!isa<TranslationUnitDecl>(DC)) {
43 S.Diag(ImportLoc, (FromInclude && S.isModuleVisible(M))
44 ? diag::ext_module_import_not_at_top_level_noop
45 : diag::err_module_import_not_at_top_level_fatal)
46 << M->getFullModuleName() << DC;
47 S.Diag(cast<Decl>(DC)->getBeginLoc(),
48 diag::note_module_import_not_at_top_level)
49 << DC;
50 } else if (!M->IsExternC && ExternCLoc.isValid()) {
51 S.Diag(ImportLoc, diag::ext_module_import_in_extern_c)
52 << M->getFullModuleName();
53 S.Diag(ExternCLoc, diag::note_extern_c_begins_here);
54 }
55 }
56
57 Sema::DeclGroupPtrTy
58 Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
59 if (!ModuleScopes.empty() &&
60 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment) {
61 // Under -std=c++2a -fmodules-ts, we can find an explicit 'module;' after
62 // already implicitly entering the global module fragment. That's OK.
63 assert(getLangOpts().CPlusPlusModules && getLangOpts().ModulesTS &&
64 "unexpectedly encountered multiple global module fragment decls");
65 ModuleScopes.back().BeginLoc = ModuleLoc;
66 return nullptr;
67 }
68
69 // We start in the global module; all those declarations are implicitly
70 // module-private (though they do not have module linkage).
71 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
72 auto *GlobalModule = Map.createGlobalModuleFragmentForModuleUnit(ModuleLoc);
73 assert(GlobalModule && "module creation should not fail");
74
75 // Enter the scope of the global module.
76 ModuleScopes.push_back({});
77 ModuleScopes.back().BeginLoc = ModuleLoc;
78 ModuleScopes.back().Module = GlobalModule;
79 VisibleModules.setVisible(GlobalModule, ModuleLoc);
80
81 // All declarations created from now on are owned by the global module.
82 auto *TU = Context.getTranslationUnitDecl();
83 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
84 TU->setLocalOwningModule(GlobalModule);
85
86 // FIXME: Consider creating an explicit representation of this declaration.
87 return nullptr;
88 }
89
90 Sema::DeclGroupPtrTy
91 Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
92 ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl) {
93 assert((getLangOpts().ModulesTS || getLangOpts().CPlusPlusModules) &&
94 "should only have module decl in Modules TS or C++20");
95
96 // A module implementation unit requires that we are not compiling a module
97 // of any kind. A module interface unit requires that we are not compiling a
98 // module map.
99 switch (getLangOpts().getCompilingModule()) {
100 case LangOptions::CMK_None:
101 // It's OK to compile a module interface as a normal translation unit.
102 break;
103
104 case LangOptions::CMK_ModuleInterface:
105 if (MDK != ModuleDeclKind::Implementation)
106 break;
107
108 // We were asked to compile a module interface unit but this is a module
109 // implementation unit. That indicates the 'export' is missing.
110 Diag(ModuleLoc, diag::err_module_interface_implementation_mismatch)
111 << FixItHint::CreateInsertion(ModuleLoc, "export ");
112 MDK = ModuleDeclKind::Interface;
113 break;
114
115 case LangOptions::CMK_ModuleMap:
116 Diag(ModuleLoc, diag::err_module_decl_in_module_map_module);
117 return nullptr;
118
119 case LangOptions::CMK_HeaderModule:
120 Diag(ModuleLoc, diag::err_module_decl_in_header_module);
121 return nullptr;
122 }
123
124 assert(ModuleScopes.size() <= 1 && "expected to be at global module scope");
125
126 // FIXME: Most of this work should be done by the preprocessor rather than
127 // here, in order to support macro import.
128
129 // Only one module-declaration is permitted per source file.
130 if (!ModuleScopes.empty() &&
131 ModuleScopes.back().Module->isModulePurview()) {
132 Diag(ModuleLoc, diag::err_module_redeclaration);
133 Diag(VisibleModules.getImportLoc(ModuleScopes.back().Module),
134 diag::note_prev_module_declaration);
135 return nullptr;
136 }
137
138 // Find the global module fragment we're adopting into this module, if any.
139 Module *GlobalModuleFragment = nullptr;
140 if (!ModuleScopes.empty() &&
141 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment)
142 GlobalModuleFragment = ModuleScopes.back().Module;
143
144 // In C++20, the module-declaration must be the first declaration if there
145 // is no global module fragment.
146 if (getLangOpts().CPlusPlusModules && !IsFirstDecl && !GlobalModuleFragment) {
147 Diag(ModuleLoc, diag::err_module_decl_not_at_start);
148 SourceLocation BeginLoc =
149 ModuleScopes.empty()
150 ? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
151 : ModuleScopes.back().BeginLoc;
152 if (BeginLoc.isValid()) {
153 Diag(BeginLoc, diag::note_global_module_introducer_missing)
154 << FixItHint::CreateInsertion(BeginLoc, "module;\n");
155 }
156 }
157
158 // Flatten the dots in a module name. Unlike Clang's hierarchical module map
159 // modules, the dots here are just another character that can appear in a
160 // module name.
161 std::string ModuleName;
162 for (auto &Piece : Path) {
163 if (!ModuleName.empty())
164 ModuleName += ".";
165 ModuleName += Piece.first->getName();
166 }
167
168 // If a module name was explicitly specified on the command line, it must be
169 // correct.
170 if (!getLangOpts().CurrentModule.empty() &&
171 getLangOpts().CurrentModule != ModuleName) {
172 Diag(Path.front().second, diag::err_current_module_name_mismatch)
173 << SourceRange(Path.front().second, Path.back().second)
174 << getLangOpts().CurrentModule;
175 return nullptr;
176 }
177 const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
178
179 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
180 Module *Mod;
181
182 switch (MDK) {
183 case ModuleDeclKind::Interface: {
184 // We can't have parsed or imported a definition of this module or parsed a
185 // module map defining it already.
186 if (auto *M = Map.findModule(ModuleName)) {
187 Diag(Path[0].second, diag::err_module_redefinition) << ModuleName;
188 if (M->DefinitionLoc.isValid())
189 Diag(M->DefinitionLoc, diag::note_prev_module_definition);
190 else if (const auto *FE = M->getASTFile())
191 Diag(M->DefinitionLoc, diag::note_prev_module_definition_from_ast_file)
192 << FE->getName();
193 Mod = M;
194 break;
195 }
196
197 // Create a Module for the module that we're defining.
198 Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
199 GlobalModuleFragment);
200 assert(Mod && "module creation should not fail");
201 break;
202 }
203
204 case ModuleDeclKind::Implementation:
205 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
206 PP.getIdentifierInfo(ModuleName), Path[0].second);
207 Mod = getModuleLoader().loadModule(ModuleLoc, {ModuleNameLoc},
208 Module::AllVisible,
209 /*IsInclusionDirective=*/false);
210 if (!Mod) {
211 Diag(ModuleLoc, diag::err_module_not_defined) << ModuleName;
212 // Create an empty module interface unit for error recovery.
213 Mod = Map.createModuleForInterfaceUnit(ModuleLoc, ModuleName,
214 GlobalModuleFragment);
215 }
216 break;
217 }
218
219 if (!GlobalModuleFragment) {
220 ModuleScopes.push_back({});
221 if (getLangOpts().ModulesLocalVisibility)
222 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
223 } else {
224 // We're done with the global module fragment now.
225 ActOnEndOfTranslationUnitFragment(TUFragmentKind::Global);
226 }
227
228 // Switch from the global module fragment (if any) to the named module.
229 ModuleScopes.back().BeginLoc = StartLoc;
230 ModuleScopes.back().Module = Mod;
231 ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
232 VisibleModules.setVisible(Mod, ModuleLoc);
233
234 // From now on, we have an owning module for all declarations we see.
235 // However, those declarations are module-private unless explicitly
236 // exported.
237 auto *TU = Context.getTranslationUnitDecl();
238 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
239 TU->setLocalOwningModule(Mod);
240
241 // FIXME: Create a ModuleDecl.
242 return nullptr;
243 }
244
245 Sema::DeclGroupPtrTy
246 Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
247 SourceLocation PrivateLoc) {
248 // C++20 [basic.link]/2:
249 // A private-module-fragment shall appear only in a primary module
250 // interface unit.
251 switch (ModuleScopes.empty() ? Module::GlobalModuleFragment
252 : ModuleScopes.back().Module->Kind) {
253 case Module::ModuleMapModule:
254 case Module::GlobalModuleFragment:
255 Diag(PrivateLoc, diag::err_private_module_fragment_not_module);
256 return nullptr;
257
258 case Module::PrivateModuleFragment:
259 Diag(PrivateLoc, diag::err_private_module_fragment_redefined);
260 Diag(ModuleScopes.back().BeginLoc, diag::note_previous_definition);
261 return nullptr;
262
263 case Module::ModuleInterfaceUnit:
264 break;
265 }
266
267 if (!ModuleScopes.back().ModuleInterface) {
268 Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);
269 Diag(ModuleScopes.back().BeginLoc,
270 diag::note_not_module_interface_add_export)
271 << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
272 return nullptr;
273 }
274
275 // FIXME: Check this isn't a module interface partition.
276 // FIXME: Check that this translation unit does not import any partitions;
277 // such imports would violate [basic.link]/2's "shall be the only module unit"
278 // restriction.
279
280 // We've finished the public fragment of the translation unit.
281 ActOnEndOfTranslationUnitFragment(TUFragmentKind::Normal);
282
283 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
284 Module *PrivateModuleFragment =
285 Map.createPrivateModuleFragmentForInterfaceUnit(
286 ModuleScopes.back().Module, PrivateLoc);
287 assert(PrivateModuleFragment && "module creation should not fail");
288
289 // Enter the scope of the private module fragment.
290 ModuleScopes.push_back({});
291 ModuleScopes.back().BeginLoc = ModuleLoc;
292 ModuleScopes.back().Module = PrivateModuleFragment;
293 ModuleScopes.back().ModuleInterface = true;
294 VisibleModules.setVisible(PrivateModuleFragment, ModuleLoc);
295
296 // All declarations created from now on are scoped to the private module
297 // fragment (and are neither visible nor reachable in importers of the module
298 // interface).
299 auto *TU = Context.getTranslationUnitDecl();
300 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
301 TU->setLocalOwningModule(PrivateModuleFragment);
302
303 // FIXME: Consider creating an explicit representation of this declaration.
304 return nullptr;
305 }
306
307 DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
308 SourceLocation ExportLoc,
309 SourceLocation ImportLoc,
310 ModuleIdPath Path) {
311 // Flatten the module path for a Modules TS module name.
312 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
313 if (getLangOpts().ModulesTS) {
314 std::string ModuleName;
315 for (auto &Piece : Path) {
316 if (!ModuleName.empty())
317 ModuleName += ".";
318 ModuleName += Piece.first->getName();
319 }
320 ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
321 Path = ModuleIdPath(ModuleNameLoc);
322 }
323
324 Module *Mod =
325 getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
326 /*IsInclusionDirective=*/false);
327 if (!Mod)
328 return true;
329
330 return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, Mod, Path);
331 }
332
333 /// Determine whether \p D is lexically within an export-declaration.
334 static const ExportDecl *getEnclosingExportDecl(const Decl *D) {
335 for (auto *DC = D->getLexicalDeclContext(); DC; DC = DC->getLexicalParent())
336 if (auto *ED = dyn_cast<ExportDecl>(DC))
337 return ED;
338 return nullptr;
339 }
340
341 DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
342 SourceLocation ExportLoc,
343 SourceLocation ImportLoc,
344 Module *Mod, ModuleIdPath Path) {
345 VisibleModules.setVisible(Mod, ImportLoc);
346
347 checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
348
349 // FIXME: we should support importing a submodule within a different submodule
350 // of the same top-level module. Until we do, make it an error rather than
351 // silently ignoring the import.
352 // Import-from-implementation is valid in the Modules TS. FIXME: Should we
353 // warn on a redundant import of the current module?
354 // FIXME: Import of a module from an implementation partition of the same
355 // module is permitted.
356 if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule &&
357 (getLangOpts().isCompilingModule() || !getLangOpts().ModulesTS)) {
358 Diag(ImportLoc, getLangOpts().isCompilingModule()
359 ? diag::err_module_self_import
360 : diag::err_module_import_in_implementation)
361 << Mod->getFullModuleName() << getLangOpts().CurrentModule;
362 }
363
364 SmallVector<SourceLocation, 2> IdentifierLocs;
365 Module *ModCheck = Mod;
366 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
367 // If we've run out of module parents, just drop the remaining identifiers.
368 // We need the length to be consistent.
369 if (!ModCheck)
370 break;
371 ModCheck = ModCheck->Parent;
372
373 IdentifierLocs.push_back(Path[I].second);
374 }
375
376 // If this was a header import, pad out with dummy locations.
377 // FIXME: Pass in and use the location of the header-name token in this case.
378 if (Path.empty()) {
379 for (; ModCheck; ModCheck = ModCheck->Parent) {
380 IdentifierLocs.push_back(SourceLocation());
381 }
382 }
383
384 ImportDecl *Import = ImportDecl::Create(Context, CurContext, StartLoc,
385 Mod, IdentifierLocs);
386 CurContext->addDecl(Import);
387
388 // Sequence initialization of the imported module before that of the current
389 // module, if any.
390 if (!ModuleScopes.empty())
391 Context.addModuleInitializer(ModuleScopes.back().Module, Import);
392
393 // Re-export the module if needed.
394 if (!ModuleScopes.empty() && ModuleScopes.back().ModuleInterface) {
395 if (ExportLoc.isValid() || getEnclosingExportDecl(Import))
396 getCurrentModule()->Exports.emplace_back(Mod, false);
397 } else if (ExportLoc.isValid()) {
398 Diag(ExportLoc, diag::err_export_not_in_module_interface);
399 }
400
401 return Import;
402 }
403
404 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
405 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
406 BuildModuleInclude(DirectiveLoc, Mod);
407 }
408
409 void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
410 // Determine whether we're in the #include buffer for a module. The #includes
411 // in that buffer do not qualify as module imports; they're just an
412 // implementation detail of us building the module.
413 //
414 // FIXME: Should we even get ActOnModuleInclude calls for those?
415 bool IsInModuleIncludes =
416 TUKind == TU_Module &&
417 getSourceManager().isWrittenInMainFile(DirectiveLoc);
418
419 bool ShouldAddImport = !IsInModuleIncludes;
420
421 // If this module import was due to an inclusion directive, create an
422 // implicit import declaration to capture it in the AST.
423 if (ShouldAddImport) {
424 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
425 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
426 DirectiveLoc, Mod,
427 DirectiveLoc);
428 if (!ModuleScopes.empty())
429 Context.addModuleInitializer(ModuleScopes.back().Module, ImportD);
430 TU->addDecl(ImportD);
431 Consumer.HandleImplicitImportDecl(ImportD);
432 }
433
434 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc);
435 VisibleModules.setVisible(Mod, DirectiveLoc);
436 }
437
438 void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
439 checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
440
441 ModuleScopes.push_back({});
442 ModuleScopes.back().Module = Mod;
443 if (getLangOpts().ModulesLocalVisibility)
444 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
445
446 VisibleModules.setVisible(Mod, DirectiveLoc);
447
448 // The enclosing context is now part of this module.
449 // FIXME: Consider creating a child DeclContext to hold the entities
450 // lexically within the module.
451 if (getLangOpts().trackLocalOwningModule()) {
452 for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
453 cast<Decl>(DC)->setModuleOwnershipKind(
454 getLangOpts().ModulesLocalVisibility
455 ? Decl::ModuleOwnershipKind::VisibleWhenImported
456 : Decl::ModuleOwnershipKind::Visible);
457 cast<Decl>(DC)->setLocalOwningModule(Mod);
458 }
459 }
460 }
461
462 void Sema::ActOnModuleEnd(SourceLocation EomLoc, Module *Mod) {
463 if (getLangOpts().ModulesLocalVisibility) {
464 VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
465 // Leaving a module hides namespace names, so our visible namespace cache
466 // is now out of date.
467 VisibleNamespaceCache.clear();
468 }
469
470 assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
471 "left the wrong module scope");
472 ModuleScopes.pop_back();
473
474 // We got to the end of processing a local module. Create an
475 // ImportDecl as we would for an imported module.
476 FileID File = getSourceManager().getFileID(EomLoc);
477 SourceLocation DirectiveLoc;
478 if (EomLoc == getSourceManager().getLocForEndOfFile(File)) {
479 // We reached the end of a #included module header. Use the #include loc.
480 assert(File != getSourceManager().getMainFileID() &&
481 "end of submodule in main source file");
482 DirectiveLoc = getSourceManager().getIncludeLoc(File);
483 } else {
484 // We reached an EOM pragma. Use the pragma location.
485 DirectiveLoc = EomLoc;
486 }
487 BuildModuleInclude(DirectiveLoc, Mod);
488
489 // Any further declarations are in whatever module we returned to.
490 if (getLangOpts().trackLocalOwningModule()) {
491 // The parser guarantees that this is the same context that we entered
492 // the module within.
493 for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
494 cast<Decl>(DC)->setLocalOwningModule(getCurrentModule());
495 if (!getCurrentModule())
496 cast<Decl>(DC)->setModuleOwnershipKind(
497 Decl::ModuleOwnershipKind::Unowned);
498 }
499 }
500 }
501
502 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
503 Module *Mod) {
504 // Bail if we're not allowed to implicitly import a module here.
505 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery ||
506 VisibleModules.isVisible(Mod))
507 return;
508
509 // Create the implicit import declaration.
510 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
511 ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
512 Loc, Mod, Loc);
513 TU->addDecl(ImportD);
514 Consumer.HandleImplicitImportDecl(ImportD);
515
516 // Make the module visible.
517 getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc);
518 VisibleModules.setVisible(Mod, Loc);
519 }
520
521 /// We have parsed the start of an export declaration, including the '{'
522 /// (if present).
523 Decl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
524 SourceLocation LBraceLoc) {
525 ExportDecl *D = ExportDecl::Create(Context, CurContext, ExportLoc);
526
527 // Set this temporarily so we know the export-declaration was braced.
528 D->setRBraceLoc(LBraceLoc);
529
530 // C++2a [module.interface]p1:
531 // An export-declaration shall appear only [...] in the purview of a module
532 // interface unit. An export-declaration shall not appear directly or
533 // indirectly within [...] a private-module-fragment.
534 if (ModuleScopes.empty() || !ModuleScopes.back().Module->isModulePurview()) {
535 Diag(ExportLoc, diag::err_export_not_in_module_interface) << 0;
536 } else if (!ModuleScopes.back().ModuleInterface) {
537 Diag(ExportLoc, diag::err_export_not_in_module_interface) << 1;
538 Diag(ModuleScopes.back().BeginLoc,
539 diag::note_not_module_interface_add_export)
540 << FixItHint::CreateInsertion(ModuleScopes.back().BeginLoc, "export ");
541 } else if (ModuleScopes.back().Module->Kind ==
542 Module::PrivateModuleFragment) {
543 Diag(ExportLoc, diag::err_export_in_private_module_fragment);
544 Diag(ModuleScopes.back().BeginLoc, diag::note_private_module_fragment);
545 }
546
547 for (const DeclContext *DC = CurContext; DC; DC = DC->getLexicalParent()) {
548 if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
549 // An export-declaration shall not appear directly or indirectly within
550 // an unnamed namespace [...]
551 if (ND->isAnonymousNamespace()) {
552 Diag(ExportLoc, diag::err_export_within_anonymous_namespace);
553 Diag(ND->getLocation(), diag::note_anonymous_namespace);
554 // Don't diagnose internal-linkage declarations in this region.
555 D->setInvalidDecl();
556 break;
557 }
558
559 // A declaration is exported if it is [...] a namespace-definition
560 // that contains an exported declaration.
561 //
562 // Defer exporting the namespace until after we leave it, in order to
563 // avoid marking all subsequent declarations in the namespace as exported.
564 if (!DeferredExportedNamespaces.insert(ND).second)
565 break;
566 }
567 }
568
569 // [...] its declaration or declaration-seq shall not contain an
570 // export-declaration.
571 if (auto *ED = getEnclosingExportDecl(D)) {
572 Diag(ExportLoc, diag::err_export_within_export);
573 if (ED->hasBraces())
574 Diag(ED->getLocation(), diag::note_export);
575 }
576
577 CurContext->addDecl(D);
578 PushDeclContext(S, D);
579 D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
580 return D;
581 }
582
583 static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
584 SourceLocation BlockStart);
585
586 namespace {
587 enum class UnnamedDeclKind {
588 Empty,
589 StaticAssert,
590 Asm,
591 UsingDirective,
592 Context
593 };
594 }
595
596 static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {
597 if (isa<EmptyDecl>(D))
598 return UnnamedDeclKind::Empty;
599 if (isa<StaticAssertDecl>(D))
600 return UnnamedDeclKind::StaticAssert;
601 if (isa<FileScopeAsmDecl>(D))
602 return UnnamedDeclKind::Asm;
603 if (isa<UsingDirectiveDecl>(D))
604 return UnnamedDeclKind::UsingDirective;
605 // Everything else either introduces one or more names or is ill-formed.
606 return llvm::None;
607 }
608
609 unsigned getUnnamedDeclDiag(UnnamedDeclKind UDK, bool InBlock) {
610 switch (UDK) {
611 case UnnamedDeclKind::Empty:
612 case UnnamedDeclKind::StaticAssert:
613 // Allow empty-declarations and static_asserts in an export block as an
614 // extension.
615 return InBlock ? diag::ext_export_no_name_block : diag::err_export_no_name;
616
617 case UnnamedDeclKind::UsingDirective:
618 // Allow exporting using-directives as an extension.
619 return diag::ext_export_using_directive;
620
621 case UnnamedDeclKind::Context:
622 // Allow exporting DeclContexts that transitively contain no declarations
623 // as an extension.
624 return diag::ext_export_no_names;
625
626 case UnnamedDeclKind::Asm:
627 return diag::err_export_no_name;
628 }
629 llvm_unreachable("unknown kind");
630 }
631
632 static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D,
633 SourceLocation BlockStart) {
634 S.Diag(D->getLocation(), getUnnamedDeclDiag(UDK, BlockStart.isValid()))
635 << (unsigned)UDK;
636 if (BlockStart.isValid())
637 S.Diag(BlockStart, diag::note_export);
638 }
639
640 /// Check that it's valid to export \p D.
641 static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {
642 // C++2a [module.interface]p3:
643 // An exported declaration shall declare at least one name
644 if (auto UDK = getUnnamedDeclKind(D))
645 diagExportedUnnamedDecl(S, *UDK, D, BlockStart);
646
647 // [...] shall not declare a name with internal linkage.
648 if (auto *ND = dyn_cast<NamedDecl>(D)) {
649 // Don't diagnose anonymous union objects; we'll diagnose their members
650 // instead.
651 if (ND->getDeclName() && ND->getFormalLinkage() == InternalLinkage) {
652 S.Diag(ND->getLocation(), diag::err_export_internal) << ND;
653 if (BlockStart.isValid())
654 S.Diag(BlockStart, diag::note_export);
655 }
656 }
657
658 // C++2a [module.interface]p5:
659 // all entities to which all of the using-declarators ultimately refer
660 // shall have been introduced with a name having external linkage
661 if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {
662 NamedDecl *Target = USD->getUnderlyingDecl();
663 if (Target->getFormalLinkage() == InternalLinkage) {
664 S.Diag(USD->getLocation(), diag::err_export_using_internal) << Target;
665 S.Diag(Target->getLocation(), diag::note_using_decl_target);
666 if (BlockStart.isValid())
667 S.Diag(BlockStart, diag::note_export);
668 }
669 }
670
671 // Recurse into namespace-scope DeclContexts. (Only namespace-scope
672 // declarations are exported.)
673 if (auto *DC = dyn_cast<DeclContext>(D))
674 if (DC->getRedeclContext()->isFileContext() && !isa<EnumDecl>(D))
675 return checkExportedDeclContext(S, DC, BlockStart);
676 return false;
677 }
678
679 /// Check that it's valid to export all the declarations in \p DC.
680 static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
681 SourceLocation BlockStart) {
682 bool AllUnnamed = true;
683 for (auto *D : DC->decls())
684 AllUnnamed &= checkExportedDecl(S, D, BlockStart);
685 return AllUnnamed;
686 }
687
688 /// Complete the definition of an export declaration.
689 Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {
690 auto *ED = cast<ExportDecl>(D);
691 if (RBraceLoc.isValid())
692 ED->setRBraceLoc(RBraceLoc);
693
694 PopDeclContext();
695
696 if (!D->isInvalidDecl()) {
697 SourceLocation BlockStart =
698 ED->hasBraces() ? ED->getBeginLoc() : SourceLocation();
699 for (auto *Child : ED->decls()) {
700 if (checkExportedDecl(*this, Child, BlockStart)) {
701 // If a top-level child is a linkage-spec declaration, it might contain
702 // no declarations (transitively), in which case it's ill-formed.
703 diagExportedUnnamedDecl(*this, UnnamedDeclKind::Context, Child,
704 BlockStart);
705 }
706 }
707 }
708
709 return D;
710 }
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:77
clang::OverloadCandidateParamOrder::Normal
clang::Sema::ActOnModuleImport
DeclResult ActOnModuleImport(SourceLocation StartLoc, SourceLocation ExportLoc, SourceLocation ImportLoc, ModuleIdPath Path)
The parser has processed a module import declaration.
Definition: SemaModule.cpp:307
clang::Sema::ActOnPrivateModuleFragmentDecl
DeclGroupPtrTy ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc)
The parser has processed a private-module-fragment declaration that begins the definition of the priv...
Definition: SemaModule.cpp:246
clang::Decl::ModuleOwnershipKind::ModulePrivate
This declaration has an owning module, but is only visible to lookups that occur within that module...
getUnnamedDeclKind
static llvm::Optional< UnnamedDeclKind > getUnnamedDeclKind(Decl *D)
Definition: SemaModule.cpp:596
clang::Module::IsExternC
unsigned IsExternC
Whether this is an &#39;extern "C"&#39; module (which implicitly puts all headers in it within an &#39;extern "C"...
Definition: Module.h:237
clang::Sema::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::Sema::isModuleVisible
bool isModuleVisible(const Module *M, bool ModulePrivate=false)
Definition: SemaLookup.cpp:1782
HeaderSearch.h
clang::OpaquePtr
Wrapper for void* pointer.
Definition: Ownership.h:50
clang::Module::ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:75
checkModuleImportContext
static void checkModuleImportContext(Sema &S, Module *M, SourceLocation ImportLoc, DeclContext *DC, bool FromInclude=false)
Definition: SemaModule.cpp:22
clang::LangOptions::CMK_ModuleInterface
Compiling a C++ modules TS module interface unit.
Definition: LangOptions.h:88
clang::DeclContext::decls
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2033
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:553
SemaInternal.h
clang::MultiVersionKind::Target
clang::Module::PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:84
clang::NamedDecl::getFormalLinkage
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:353
llvm::Optional
Definition: LLVM.h:37
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:53
clang::ModuleIdPath
ArrayRef< std::pair< IdentifierInfo *, SourceLocation > > ModuleIdPath
A sequence of identifier/location pairs used to describe a particular module or submodule, e.g., std.vector.
Definition: ModuleLoader.h:32
clang::LangOptions::CMK_ModuleMap
Compiling a module from a module map.
Definition: LangOptions.h:82
clang::Module
Describes a module or submodule.
Definition: Module.h:64
clang::Module::getTopLevelModuleName
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:467
clang::LinkageSpecDecl::lang_c
Definition: DeclCXX.h:2787
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:213
clang::Module::Parent
Module * Parent
The parent of this module.
Definition: Module.h:92
clang::Sema::ActOnModuleInclude
void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
The parser has processed a module import translated from a #include or similar preprocessing directiv...
Definition: SemaModule.cpp:404
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::Decl::getLexicalDeclContext
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
llvm::ArrayRef
Definition: LLVM.h:31
checkExportedDecl
static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart)
Check that it&#39;s valid to export D.
Definition: SemaModule.cpp:641
clang::ImportDecl::Create
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
Definition: Decl.cpp:4937
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
clang::DeclContext::getLexicalParent
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1800
clang::Sema::ModuleDeclKind
ModuleDeclKind
Definition: Sema.h:2395
clang::LangOptions::CMK_HeaderModule
Compiling a module from a list of header files.
Definition: LangOptions.h:85
clang::Decl::setInvalidDecl
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
Preprocessor.h
Defines the clang::Preprocessor interface.
clang::LangOptions::CMK_None
Not compiling a module interface at all.
Definition: LangOptions.h:79
clang::DeclContext::isFileContext
bool isFileContext() const
Definition: DeclBase.h:1854
UnnamedDeclKind
UnnamedDeclKind
Definition: SemaModule.cpp:587
clang::Sema::ActOnFinishExportDecl
Decl * ActOnFinishExportDecl(Scope *S, Decl *ExportDecl, SourceLocation RBraceLoc)
Complete the definition of an export declaration.
Definition: SemaModule.cpp:689
clang::Module::Module
Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, bool IsFramework, bool IsExplicit, unsigned VisibilityID)
Construct a new module or submodule.
Definition: Module.cpp:37
clang::Decl::ModuleOwnershipKind::VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
ASTConsumer.h
clang::Sema::BuildModuleInclude
void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod)
Definition: SemaModule.cpp:409
clang::ExportDecl
Represents a C++ Modules TS module export declaration.
Definition: Decl.h:4396
clang::Decl::ModuleOwnershipKind::Visible
This declaration has an owning module, but is globally visible (typically because its owning module i...
clang::ActionResult
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
clang::LinkageSpecDecl::lang_cxx
Definition: DeclCXX.h:2787
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ExportDecl::Create
static ExportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExportLoc)
Definition: Decl.cpp:4983
clang::Decl::setModuleOwnershipKind
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:791
checkExportedDeclContext
static bool checkExportedDeclContext(Sema &S, DeclContext *DC, SourceLocation BlockStart)
Check that it&#39;s valid to export all the declarations in DC.
Definition: SemaModule.cpp:680
clang::Sema::ActOnGlobalModuleFragmentDecl
DeclGroupPtrTy ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc)
The parser has processed a global-module-fragment declaration that begins the definition of the globa...
Definition: SemaModule.cpp:58
clang::Module::GlobalModuleFragment
This is a fragment of the global module within some C++ module.
Definition: Module.h:81
llvm::SmallVector
Definition: LLVM.h:35
clang::Sema::ActOnStartExportDecl
Decl * ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, SourceLocation LBraceLoc)
We have parsed the start of an export declaration, including the &#39;{&#39; (if present).
Definition: SemaModule.cpp:523
clang::ImportDecl::CreateImplicit
static ImportDecl * CreateImplicit(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc)
Create a new module import declaration for an implicitly-generated import.
Definition: Decl.cpp:4945
clang::MultiVersionKind::None
clang::ImportDecl
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4331
clang::Sema::createImplicitModuleImportForErrorRecovery
void createImplicitModuleImportForErrorRecovery(SourceLocation Loc, Module *Mod)
Create an implicit import of the given module at the given source location, for error recovery...
Definition: SemaModule.cpp:502
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:106
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
clang::Sema::ActOnModuleBegin
void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod)
The parsed has entered a submodule.
Definition: SemaModule.cpp:438
getUnnamedDeclDiag
unsigned getUnnamedDeclDiag(UnnamedDeclKind UDK, bool InBlock)
Definition: SemaModule.cpp:609
clang::Decl::ModuleOwnershipKind::Unowned
This declaration is not owned by a module.
clang::Module::AllVisible
All of the names in this module are visible.
Definition: Module.h:277
clang::Language::Asm
Assembly: we accept this only so that we can preprocess it.
getEnclosingExportDecl
static const ExportDecl * getEnclosingExportDecl(const Decl *D)
Determine whether D is lexically within an export-declaration.
Definition: SemaModule.cpp:334
clang::DeclContext::getRedeclContext
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1747
clang::Sema::ActOnModuleDecl
DeclGroupPtrTy ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc, ModuleDeclKind MDK, ModuleIdPath Path, bool IsFirstDecl)
The parser has processed a module-declaration that begins the definition of a module interface or imp...
Definition: SemaModule.cpp:91
clang::InternalLinkage
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:31
clang::FixItHint::CreateInsertion
static FixItHint CreateInsertion(SourceLocation InsertionLoc, StringRef Code, bool BeforePreviousInsertions=false)
Create a code modification hint that inserts the given code string at a specific location.
Definition: Diagnostic.h:92
clang::DeclContext::addDecl
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1524
diagExportedUnnamedDecl
static void diagExportedUnnamedDecl(Sema &S, UnnamedDeclKind UDK, Decl *D, SourceLocation BlockStart)
Definition: SemaModule.cpp:632
clang::ExportDecl::setRBraceLoc
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:4416
clang::ASTContext::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
clang::ASTContext::addModuleInitializer
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
Definition: ASTContext.cpp:1200
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:107
clang::TranslationUnitDecl
The top declaration context.
Definition: Decl.h:82
clang::Sema::ActOnModuleEnd
void ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod)
The parser has left a submodule.
Definition: SemaModule.cpp:462
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::Decl::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl()
Definition: DeclBase.cpp:362
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:429
clang::Module::ModuleInterfaceUnit
This is a C++ Modules TS module interface unit.
Definition: Module.h:78
clang::TU_Module
The translation unit is a module.
Definition: LangOptions.h:421