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/AST/ASTMutationListener.h"
16#include "clang/Lex/HeaderSearch.h"
17#include "clang/Lex/Preprocessor.h"
18#include "clang/Sema/SemaInternal.h"
19#include "llvm/ADT/StringExtras.h"
20#include <optional>
21
22using namespace clang;
23using namespace sema;
24
25static void checkModuleImportContext(Sema &S, Module *M,
26 SourceLocation ImportLoc, DeclContext *DC,
27 bool FromInclude = false) {
28 SourceLocation ExternCLoc;
29
30 if (auto *LSD = dyn_cast<LinkageSpecDecl>(Val: DC)) {
31 switch (LSD->getLanguage()) {
32 case LinkageSpecLanguageIDs::C:
33 if (ExternCLoc.isInvalid())
34 ExternCLoc = LSD->getBeginLoc();
35 break;
36 case LinkageSpecLanguageIDs::CXX:
37 break;
38 }
39 DC = LSD->getParent();
40 }
41
42 while (isa<LinkageSpecDecl>(Val: DC) || isa<ExportDecl>(Val: DC))
43 DC = DC->getParent();
44
45 if (!isa<TranslationUnitDecl>(Val: DC)) {
46 S.Diag(Loc: ImportLoc, DiagID: (FromInclude && S.isModuleVisible(M))
47 ? diag::ext_module_import_not_at_top_level_noop
48 : diag::err_module_import_not_at_top_level_fatal)
49 << M->getFullModuleName() << DC;
50 S.Diag(Loc: cast<Decl>(Val: DC)->getBeginLoc(),
51 DiagID: diag::note_module_import_not_at_top_level)
52 << DC;
53 } else if (!M->IsExternC && ExternCLoc.isValid()) {
54 S.Diag(Loc: ImportLoc, DiagID: diag::ext_module_import_in_extern_c)
55 << M->getFullModuleName();
56 S.Diag(Loc: ExternCLoc, DiagID: diag::note_extern_c_begins_here);
57 }
58}
59
60// We represent the primary and partition names as 'Paths' which are sections
61// of the hierarchical access path for a clang module. However for C++20
62// the periods in a name are just another character, and we will need to
63// flatten them into a string.
64static std::string stringFromPath(ModuleIdPath Path) {
65 std::string Name;
66 if (Path.empty())
67 return Name;
68
69 for (auto &Piece : Path) {
70 if (!Name.empty())
71 Name += ".";
72 Name += Piece.first->getName();
73 }
74 return Name;
75}
76
77/// Helper function for makeTransitiveImportsVisible to decide whether
78/// the \param Imported module unit is in the same module with the \param
79/// CurrentModule.
80/// \param FoundPrimaryModuleInterface is a helper parameter to record the
81/// primary module interface unit corresponding to the module \param
82/// CurrentModule. Since currently it is expensive to decide whether two module
83/// units come from the same module by comparing the module name.
84static bool
85isImportingModuleUnitFromSameModule(ASTContext &Ctx, Module *Imported,
86 Module *CurrentModule,
87 Module *&FoundPrimaryModuleInterface) {
88 if (!Imported->isNamedModule())
89 return false;
90
91 // The a partition unit we're importing must be in the same module of the
92 // current module.
93 if (Imported->isModulePartition())
94 return true;
95
96 // If we found the primary module interface during the search process, we can
97 // return quickly to avoid expensive string comparison.
98 if (FoundPrimaryModuleInterface)
99 return Imported == FoundPrimaryModuleInterface;
100
101 if (!CurrentModule)
102 return false;
103
104 // Then the imported module must be a primary module interface unit. It
105 // is only allowed to import the primary module interface unit from the same
106 // module in the implementation unit and the implementation partition unit.
107
108 // Since we'll handle implementation unit above. We can only care
109 // about the implementation partition unit here.
110 if (!CurrentModule->isModulePartitionImplementation())
111 return false;
112
113 if (Ctx.isInSameModule(M1: Imported, M2: CurrentModule)) {
114 assert(!FoundPrimaryModuleInterface ||
115 FoundPrimaryModuleInterface == Imported);
116 FoundPrimaryModuleInterface = Imported;
117 return true;
118 }
119
120 return false;
121}
122
123/// [module.import]p7:
124/// Additionally, when a module-import-declaration in a module unit of some
125/// module M imports another module unit U of M, it also imports all
126/// translation units imported by non-exported module-import-declarations in
127/// the module unit purview of U. These rules can in turn lead to the
128/// importation of yet more translation units.
129static void
130makeTransitiveImportsVisible(ASTContext &Ctx, VisibleModuleSet &VisibleModules,
131 Module *Imported, Module *CurrentModule,
132 SourceLocation ImportLoc,
133 bool IsImportingPrimaryModuleInterface = false) {
134 assert(Imported->isNamedModule() &&
135 "'makeTransitiveImportsVisible()' is intended for standard C++ named "
136 "modules only.");
137
138 llvm::SmallVector<Module *, 4> Worklist;
139 Worklist.push_back(Elt: Imported);
140
141 Module *FoundPrimaryModuleInterface =
142 IsImportingPrimaryModuleInterface ? Imported : nullptr;
143
144 while (!Worklist.empty()) {
145 Module *Importing = Worklist.pop_back_val();
146
147 if (VisibleModules.isVisible(M: Importing))
148 continue;
149
150 // FIXME: The ImportLoc here is not meaningful. It may be problematic if we
151 // use the sourcelocation loaded from the visible modules.
152 VisibleModules.setVisible(M: Importing, Loc: ImportLoc);
153
154 if (isImportingModuleUnitFromSameModule(Ctx, Imported: Importing, CurrentModule,
155 FoundPrimaryModuleInterface))
156 for (Module *TransImported : Importing->Imports)
157 if (!VisibleModules.isVisible(M: TransImported))
158 Worklist.push_back(Elt: TransImported);
159 }
160}
161
162Sema::DeclGroupPtrTy
163Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
164 // We start in the global module;
165 Module *GlobalModule =
166 PushGlobalModuleFragment(BeginLoc: ModuleLoc);
167
168 // All declarations created from now on are owned by the global module.
169 auto *TU = Context.getTranslationUnitDecl();
170 // [module.global.frag]p2
171 // A global-module-fragment specifies the contents of the global module
172 // fragment for a module unit. The global module fragment can be used to
173 // provide declarations that are attached to the global module and usable
174 // within the module unit.
175 //
176 // So the declations in the global module shouldn't be visible by default.
177 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
178 TU->setLocalOwningModule(GlobalModule);
179
180 // FIXME: Consider creating an explicit representation of this declaration.
181 return nullptr;
182}
183
184void Sema::HandleStartOfHeaderUnit() {
185 assert(getLangOpts().CPlusPlusModules &&
186 "Header units are only valid for C++20 modules");
187 SourceLocation StartOfTU =
188 SourceMgr.getLocForStartOfFile(FID: SourceMgr.getMainFileID());
189
190 StringRef HUName = getLangOpts().CurrentModule;
191 if (HUName.empty()) {
192 HUName =
193 SourceMgr.getFileEntryRefForID(FID: SourceMgr.getMainFileID())->getName();
194 const_cast<LangOptions &>(getLangOpts()).CurrentModule = HUName.str();
195 }
196
197 // TODO: Make the C++20 header lookup independent.
198 // When the input is pre-processed source, we need a file ref to the original
199 // file for the header map.
200 auto F = SourceMgr.getFileManager().getOptionalFileRef(Filename: HUName);
201 // For the sake of error recovery (if someone has moved the original header
202 // after creating the pre-processed output) fall back to obtaining the file
203 // ref for the input file, which must be present.
204 if (!F)
205 F = SourceMgr.getFileEntryRefForID(FID: SourceMgr.getMainFileID());
206 assert(F && "failed to find the header unit source?");
207 Module::Header H{.NameAsWritten: HUName.str(), .PathRelativeToRootModuleDirectory: HUName.str(), .Entry: *F};
208 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
209 Module *Mod = Map.createHeaderUnit(Loc: StartOfTU, Name: HUName, H);
210 assert(Mod && "module creation should not fail");
211 ModuleScopes.push_back(Elt: {}); // No GMF
212 ModuleScopes.back().BeginLoc = StartOfTU;
213 ModuleScopes.back().Module = Mod;
214 VisibleModules.setVisible(M: Mod, Loc: StartOfTU);
215
216 // From now on, we have an owning module for all declarations we see.
217 // All of these are implicitly exported.
218 auto *TU = Context.getTranslationUnitDecl();
219 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
220 TU->setLocalOwningModule(Mod);
221}
222
223/// Tests whether the given identifier is reserved as a module name and
224/// diagnoses if it is. Returns true if a diagnostic is emitted and false
225/// otherwise.
226static bool DiagReservedModuleName(Sema &S, const IdentifierInfo *II,
227 SourceLocation Loc) {
228 enum {
229 Valid = -1,
230 Invalid = 0,
231 Reserved = 1,
232 } Reason = Valid;
233
234 if (II->isStr(Str: "module") || II->isStr(Str: "import"))
235 Reason = Invalid;
236 else if (II->isReserved(LangOpts: S.getLangOpts()) !=
237 ReservedIdentifierStatus::NotReserved)
238 Reason = Reserved;
239
240 // If the identifier is reserved (not invalid) but is in a system header,
241 // we do not diagnose (because we expect system headers to use reserved
242 // identifiers).
243 if (Reason == Reserved && S.getSourceManager().isInSystemHeader(Loc))
244 Reason = Valid;
245
246 switch (Reason) {
247 case Valid:
248 return false;
249 case Invalid:
250 return S.Diag(Loc, DiagID: diag::err_invalid_module_name) << II;
251 case Reserved:
252 S.Diag(Loc, DiagID: diag::warn_reserved_module_name) << II;
253 return false;
254 }
255 llvm_unreachable("fell off a fully covered switch");
256}
257
258Sema::DeclGroupPtrTy
259Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
260 ModuleDeclKind MDK, ModuleIdPath Path,
261 ModuleIdPath Partition, ModuleImportState &ImportState) {
262 assert(getLangOpts().CPlusPlusModules &&
263 "should only have module decl in standard C++ modules");
264
265 bool IsFirstDecl = ImportState == ModuleImportState::FirstDecl;
266 bool SeenGMF = ImportState == ModuleImportState::GlobalFragment;
267 // If any of the steps here fail, we count that as invalidating C++20
268 // module state;
269 ImportState = ModuleImportState::NotACXX20Module;
270
271 bool IsPartition = !Partition.empty();
272 if (IsPartition)
273 switch (MDK) {
274 case ModuleDeclKind::Implementation:
275 MDK = ModuleDeclKind::PartitionImplementation;
276 break;
277 case ModuleDeclKind::Interface:
278 MDK = ModuleDeclKind::PartitionInterface;
279 break;
280 default:
281 llvm_unreachable("how did we get a partition type set?");
282 }
283
284 // A (non-partition) module implementation unit requires that we are not
285 // compiling a module of any kind. A partition implementation emits an
286 // interface (and the AST for the implementation), which will subsequently
287 // be consumed to emit a binary.
288 // A module interface unit requires that we are not compiling a module map.
289 switch (getLangOpts().getCompilingModule()) {
290 case LangOptions::CMK_None:
291 // It's OK to compile a module interface as a normal translation unit.
292 break;
293
294 case LangOptions::CMK_ModuleInterface:
295 if (MDK != ModuleDeclKind::Implementation)
296 break;
297
298 // We were asked to compile a module interface unit but this is a module
299 // implementation unit.
300 Diag(Loc: ModuleLoc, DiagID: diag::err_module_interface_implementation_mismatch)
301 << FixItHint::CreateInsertion(InsertionLoc: ModuleLoc, Code: "export ");
302 MDK = ModuleDeclKind::Interface;
303 break;
304
305 case LangOptions::CMK_ModuleMap:
306 Diag(Loc: ModuleLoc, DiagID: diag::err_module_decl_in_module_map_module);
307 return nullptr;
308
309 case LangOptions::CMK_HeaderUnit:
310 Diag(Loc: ModuleLoc, DiagID: diag::err_module_decl_in_header_unit);
311 return nullptr;
312 }
313
314 assert(ModuleScopes.size() <= 1 && "expected to be at global module scope");
315
316 // FIXME: Most of this work should be done by the preprocessor rather than
317 // here, in order to support macro import.
318
319 // Only one module-declaration is permitted per source file.
320 if (isCurrentModulePurview()) {
321 Diag(Loc: ModuleLoc, DiagID: diag::err_module_redeclaration);
322 Diag(Loc: VisibleModules.getImportLoc(M: ModuleScopes.back().Module),
323 DiagID: diag::note_prev_module_declaration);
324 return nullptr;
325 }
326
327 assert((!getLangOpts().CPlusPlusModules ||
328 SeenGMF == (bool)this->TheGlobalModuleFragment) &&
329 "mismatched global module state");
330
331 // In C++20, the module-declaration must be the first declaration if there
332 // is no global module fragment.
333 if (getLangOpts().CPlusPlusModules && !IsFirstDecl && !SeenGMF) {
334 Diag(Loc: ModuleLoc, DiagID: diag::err_module_decl_not_at_start);
335 SourceLocation BeginLoc =
336 ModuleScopes.empty()
337 ? SourceMgr.getLocForStartOfFile(FID: SourceMgr.getMainFileID())
338 : ModuleScopes.back().BeginLoc;
339 if (BeginLoc.isValid()) {
340 Diag(Loc: BeginLoc, DiagID: diag::note_global_module_introducer_missing)
341 << FixItHint::CreateInsertion(InsertionLoc: BeginLoc, Code: "module;\n");
342 }
343 }
344
345 // C++23 [module.unit]p1: ... The identifiers module and import shall not
346 // appear as identifiers in a module-name or module-partition. All
347 // module-names either beginning with an identifier consisting of std
348 // followed by zero or more digits or containing a reserved identifier
349 // ([lex.name]) are reserved and shall not be specified in a
350 // module-declaration; no diagnostic is required.
351
352 // Test the first part of the path to see if it's std[0-9]+ but allow the
353 // name in a system header.
354 StringRef FirstComponentName = Path[0].first->getName();
355 if (!getSourceManager().isInSystemHeader(Loc: Path[0].second) &&
356 (FirstComponentName == "std" ||
357 (FirstComponentName.starts_with(Prefix: "std") &&
358 llvm::all_of(Range: FirstComponentName.drop_front(N: 3), P: &llvm::isDigit))))
359 Diag(Loc: Path[0].second, DiagID: diag::warn_reserved_module_name) << Path[0].first;
360
361 // Then test all of the components in the path to see if any of them are
362 // using another kind of reserved or invalid identifier.
363 for (auto Part : Path) {
364 if (DiagReservedModuleName(S&: *this, II: Part.first, Loc: Part.second))
365 return nullptr;
366 }
367
368 // Flatten the dots in a module name. Unlike Clang's hierarchical module map
369 // modules, the dots here are just another character that can appear in a
370 // module name.
371 std::string ModuleName = stringFromPath(Path);
372 if (IsPartition) {
373 ModuleName += ":";
374 ModuleName += stringFromPath(Path: Partition);
375 }
376 // If a module name was explicitly specified on the command line, it must be
377 // correct.
378 if (!getLangOpts().CurrentModule.empty() &&
379 getLangOpts().CurrentModule != ModuleName) {
380 Diag(Loc: Path.front().second, DiagID: diag::err_current_module_name_mismatch)
381 << SourceRange(Path.front().second, IsPartition
382 ? Partition.back().second
383 : Path.back().second)
384 << getLangOpts().CurrentModule;
385 return nullptr;
386 }
387 const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
388
389 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
390 Module *Mod; // The module we are creating.
391 Module *Interface = nullptr; // The interface for an implementation.
392 switch (MDK) {
393 case ModuleDeclKind::Interface:
394 case ModuleDeclKind::PartitionInterface: {
395 // We can't have parsed or imported a definition of this module or parsed a
396 // module map defining it already.
397 if (auto *M = Map.findModule(Name: ModuleName)) {
398 Diag(Loc: Path[0].second, DiagID: diag::err_module_redefinition) << ModuleName;
399 if (M->DefinitionLoc.isValid())
400 Diag(Loc: M->DefinitionLoc, DiagID: diag::note_prev_module_definition);
401 else if (OptionalFileEntryRef FE = M->getASTFile())
402 Diag(Loc: M->DefinitionLoc, DiagID: diag::note_prev_module_definition_from_ast_file)
403 << FE->getName();
404 Mod = M;
405 break;
406 }
407
408 // Create a Module for the module that we're defining.
409 Mod = Map.createModuleForInterfaceUnit(Loc: ModuleLoc, Name: ModuleName);
410 if (MDK == ModuleDeclKind::PartitionInterface)
411 Mod->Kind = Module::ModulePartitionInterface;
412 assert(Mod && "module creation should not fail");
413 break;
414 }
415
416 case ModuleDeclKind::Implementation: {
417 // C++20 A module-declaration that contains neither an export-
418 // keyword nor a module-partition implicitly imports the primary
419 // module interface unit of the module as if by a module-import-
420 // declaration.
421 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc(
422 PP.getIdentifierInfo(Name: ModuleName), Path[0].second);
423
424 // The module loader will assume we're trying to import the module that
425 // we're building if `LangOpts.CurrentModule` equals to 'ModuleName'.
426 // Change the value for `LangOpts.CurrentModule` temporarily to make the
427 // module loader work properly.
428 const_cast<LangOptions &>(getLangOpts()).CurrentModule = "";
429 Interface = getModuleLoader().loadModule(ImportLoc: ModuleLoc, Path: {ModuleNameLoc},
430 Visibility: Module::AllVisible,
431 /*IsInclusionDirective=*/false);
432 const_cast<LangOptions&>(getLangOpts()).CurrentModule = ModuleName;
433
434 if (!Interface) {
435 Diag(Loc: ModuleLoc, DiagID: diag::err_module_not_defined) << ModuleName;
436 // Create an empty module interface unit for error recovery.
437 Mod = Map.createModuleForInterfaceUnit(Loc: ModuleLoc, Name: ModuleName);
438 } else {
439 Mod = Map.createModuleForImplementationUnit(Loc: ModuleLoc, Name: ModuleName);
440 }
441 } break;
442
443 case ModuleDeclKind::PartitionImplementation:
444 // Create an interface, but note that it is an implementation
445 // unit.
446 Mod = Map.createModuleForInterfaceUnit(Loc: ModuleLoc, Name: ModuleName);
447 Mod->Kind = Module::ModulePartitionImplementation;
448 break;
449 }
450
451 if (!this->TheGlobalModuleFragment) {
452 ModuleScopes.push_back(Elt: {});
453 if (getLangOpts().ModulesLocalVisibility)
454 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
455 } else {
456 // We're done with the global module fragment now.
457 ActOnEndOfTranslationUnitFragment(Kind: TUFragmentKind::Global);
458 }
459
460 // Switch from the global module fragment (if any) to the named module.
461 ModuleScopes.back().BeginLoc = StartLoc;
462 ModuleScopes.back().Module = Mod;
463 VisibleModules.setVisible(M: Mod, Loc: ModuleLoc);
464
465 // From now on, we have an owning module for all declarations we see.
466 // In C++20 modules, those declaration would be reachable when imported
467 // unless explicitily exported.
468 // Otherwise, those declarations are module-private unless explicitly
469 // exported.
470 auto *TU = Context.getTranslationUnitDecl();
471 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
472 TU->setLocalOwningModule(Mod);
473
474 // We are in the module purview, but before any other (non import)
475 // statements, so imports are allowed.
476 ImportState = ModuleImportState::ImportAllowed;
477
478 getASTContext().setCurrentNamedModule(Mod);
479
480 if (auto *Listener = getASTMutationListener())
481 Listener->EnteringModulePurview();
482
483 // We already potentially made an implicit import (in the case of a module
484 // implementation unit importing its interface). Make this module visible
485 // and return the import decl to be added to the current TU.
486 if (Interface) {
487
488 makeTransitiveImportsVisible(Ctx&: getASTContext(), VisibleModules, Imported: Interface,
489 CurrentModule: Mod, ImportLoc: ModuleLoc,
490 /*IsImportingPrimaryModuleInterface=*/true);
491
492 // Make the import decl for the interface in the impl module.
493 ImportDecl *Import = ImportDecl::Create(C&: Context, DC: CurContext, StartLoc: ModuleLoc,
494 Imported: Interface, IdentifierLocs: Path[0].second);
495 CurContext->addDecl(D: Import);
496
497 // Sequence initialization of the imported module before that of the current
498 // module, if any.
499 Context.addModuleInitializer(M: ModuleScopes.back().Module, Init: Import);
500 Mod->Imports.insert(X: Interface); // As if we imported it.
501 // Also save this as a shortcut to checking for decls in the interface
502 ThePrimaryInterface = Interface;
503 // If we made an implicit import of the module interface, then return the
504 // imported module decl.
505 return ConvertDeclToDeclGroup(Ptr: Import);
506 }
507
508 return nullptr;
509}
510
511Sema::DeclGroupPtrTy
512Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc,
513 SourceLocation PrivateLoc) {
514 // C++20 [basic.link]/2:
515 // A private-module-fragment shall appear only in a primary module
516 // interface unit.
517 switch (ModuleScopes.empty() ? Module::ExplicitGlobalModuleFragment
518 : ModuleScopes.back().Module->Kind) {
519 case Module::ModuleMapModule:
520 case Module::ExplicitGlobalModuleFragment:
521 case Module::ImplicitGlobalModuleFragment:
522 case Module::ModulePartitionImplementation:
523 case Module::ModulePartitionInterface:
524 case Module::ModuleHeaderUnit:
525 Diag(Loc: PrivateLoc, DiagID: diag::err_private_module_fragment_not_module);
526 return nullptr;
527
528 case Module::PrivateModuleFragment:
529 Diag(Loc: PrivateLoc, DiagID: diag::err_private_module_fragment_redefined);
530 Diag(Loc: ModuleScopes.back().BeginLoc, DiagID: diag::note_previous_definition);
531 return nullptr;
532
533 case Module::ModuleImplementationUnit:
534 Diag(Loc: PrivateLoc, DiagID: diag::err_private_module_fragment_not_module_interface);
535 Diag(Loc: ModuleScopes.back().BeginLoc,
536 DiagID: diag::note_not_module_interface_add_export)
537 << FixItHint::CreateInsertion(InsertionLoc: ModuleScopes.back().BeginLoc, Code: "export ");
538 return nullptr;
539
540 case Module::ModuleInterfaceUnit:
541 break;
542 }
543
544 // FIXME: Check that this translation unit does not import any partitions;
545 // such imports would violate [basic.link]/2's "shall be the only module unit"
546 // restriction.
547
548 // We've finished the public fragment of the translation unit.
549 ActOnEndOfTranslationUnitFragment(Kind: TUFragmentKind::Normal);
550
551 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
552 Module *PrivateModuleFragment =
553 Map.createPrivateModuleFragmentForInterfaceUnit(
554 Parent: ModuleScopes.back().Module, Loc: PrivateLoc);
555 assert(PrivateModuleFragment && "module creation should not fail");
556
557 // Enter the scope of the private module fragment.
558 ModuleScopes.push_back(Elt: {});
559 ModuleScopes.back().BeginLoc = ModuleLoc;
560 ModuleScopes.back().Module = PrivateModuleFragment;
561 VisibleModules.setVisible(M: PrivateModuleFragment, Loc: ModuleLoc);
562
563 // All declarations created from now on are scoped to the private module
564 // fragment (and are neither visible nor reachable in importers of the module
565 // interface).
566 auto *TU = Context.getTranslationUnitDecl();
567 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
568 TU->setLocalOwningModule(PrivateModuleFragment);
569
570 // FIXME: Consider creating an explicit representation of this declaration.
571 return nullptr;
572}
573
574DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
575 SourceLocation ExportLoc,
576 SourceLocation ImportLoc, ModuleIdPath Path,
577 bool IsPartition) {
578 assert((!IsPartition || getLangOpts().CPlusPlusModules) &&
579 "partition seen in non-C++20 code?");
580
581 // For a C++20 module name, flatten into a single identifier with the source
582 // location of the first component.
583 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
584
585 std::string ModuleName;
586 if (IsPartition) {
587 // We already checked that we are in a module purview in the parser.
588 assert(!ModuleScopes.empty() && "in a module purview, but no module?");
589 Module *NamedMod = ModuleScopes.back().Module;
590 // If we are importing into a partition, find the owning named module,
591 // otherwise, the name of the importing named module.
592 ModuleName = NamedMod->getPrimaryModuleInterfaceName().str();
593 ModuleName += ":";
594 ModuleName += stringFromPath(Path);
595 ModuleNameLoc = {PP.getIdentifierInfo(Name: ModuleName), Path[0].second};
596 Path = ModuleIdPath(ModuleNameLoc);
597 } else if (getLangOpts().CPlusPlusModules) {
598 ModuleName = stringFromPath(Path);
599 ModuleNameLoc = {PP.getIdentifierInfo(Name: ModuleName), Path[0].second};
600 Path = ModuleIdPath(ModuleNameLoc);
601 }
602
603 // Diagnose self-import before attempting a load.
604 // [module.import]/9
605 // A module implementation unit of a module M that is not a module partition
606 // shall not contain a module-import-declaration nominating M.
607 // (for an implementation, the module interface is imported implicitly,
608 // but that's handled in the module decl code).
609
610 if (getLangOpts().CPlusPlusModules && isCurrentModulePurview() &&
611 getCurrentModule()->Name == ModuleName) {
612 Diag(Loc: ImportLoc, DiagID: diag::err_module_self_import_cxx20)
613 << ModuleName << currentModuleIsImplementation();
614 return true;
615 }
616
617 Module *Mod = getModuleLoader().loadModule(
618 ImportLoc, Path, Visibility: Module::AllVisible, /*IsInclusionDirective=*/false);
619 if (!Mod)
620 return true;
621
622 if (!Mod->isInterfaceOrPartition() && !ModuleName.empty() &&
623 !getLangOpts().ObjC) {
624 Diag(Loc: ImportLoc, DiagID: diag::err_module_import_non_interface_nor_parition)
625 << ModuleName;
626 return true;
627 }
628
629 return ActOnModuleImport(StartLoc, ExportLoc, ImportLoc, M: Mod, Path);
630}
631
632/// Determine whether \p D is lexically within an export-declaration.
633static const ExportDecl *getEnclosingExportDecl(const Decl *D) {
634 for (auto *DC = D->getLexicalDeclContext(); DC; DC = DC->getLexicalParent())
635 if (auto *ED = dyn_cast<ExportDecl>(Val: DC))
636 return ED;
637 return nullptr;
638}
639
640DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
641 SourceLocation ExportLoc,
642 SourceLocation ImportLoc, Module *Mod,
643 ModuleIdPath Path) {
644 if (Mod->isHeaderUnit())
645 Diag(Loc: ImportLoc, DiagID: diag::warn_experimental_header_unit);
646
647 if (Mod->isNamedModule())
648 makeTransitiveImportsVisible(Ctx&: getASTContext(), VisibleModules, Imported: Mod,
649 CurrentModule: getCurrentModule(), ImportLoc);
650 else
651 VisibleModules.setVisible(M: Mod, Loc: ImportLoc);
652
653 checkModuleImportContext(S&: *this, M: Mod, ImportLoc, DC: CurContext);
654
655 // FIXME: we should support importing a submodule within a different submodule
656 // of the same top-level module. Until we do, make it an error rather than
657 // silently ignoring the import.
658 // FIXME: Should we warn on a redundant import of the current module?
659 if (Mod->isForBuilding(LangOpts: getLangOpts())) {
660 Diag(Loc: ImportLoc, DiagID: getLangOpts().isCompilingModule()
661 ? diag::err_module_self_import
662 : diag::err_module_import_in_implementation)
663 << Mod->getFullModuleName() << getLangOpts().CurrentModule;
664 }
665
666 SmallVector<SourceLocation, 2> IdentifierLocs;
667
668 if (Path.empty()) {
669 // If this was a header import, pad out with dummy locations.
670 // FIXME: Pass in and use the location of the header-name token in this
671 // case.
672 for (Module *ModCheck = Mod; ModCheck; ModCheck = ModCheck->Parent)
673 IdentifierLocs.push_back(Elt: SourceLocation());
674 } else if (getLangOpts().CPlusPlusModules && !Mod->Parent) {
675 // A single identifier for the whole name.
676 IdentifierLocs.push_back(Elt: Path[0].second);
677 } else {
678 Module *ModCheck = Mod;
679 for (unsigned I = 0, N = Path.size(); I != N; ++I) {
680 // If we've run out of module parents, just drop the remaining
681 // identifiers. We need the length to be consistent.
682 if (!ModCheck)
683 break;
684 ModCheck = ModCheck->Parent;
685
686 IdentifierLocs.push_back(Elt: Path[I].second);
687 }
688 }
689
690 ImportDecl *Import = ImportDecl::Create(C&: Context, DC: CurContext, StartLoc,
691 Imported: Mod, IdentifierLocs);
692 CurContext->addDecl(D: Import);
693
694 // Sequence initialization of the imported module before that of the current
695 // module, if any.
696 if (!ModuleScopes.empty())
697 Context.addModuleInitializer(M: ModuleScopes.back().Module, Init: Import);
698
699 // A module (partition) implementation unit shall not be exported.
700 if (getLangOpts().CPlusPlusModules && ExportLoc.isValid() &&
701 Mod->Kind == Module::ModuleKind::ModulePartitionImplementation) {
702 Diag(Loc: ExportLoc, DiagID: diag::err_export_partition_impl)
703 << SourceRange(ExportLoc, Path.back().second);
704 } else if (!ModuleScopes.empty() && !currentModuleIsImplementation()) {
705 // Re-export the module if the imported module is exported.
706 // Note that we don't need to add re-exported module to Imports field
707 // since `Exports` implies the module is imported already.
708 if (ExportLoc.isValid() || getEnclosingExportDecl(D: Import))
709 getCurrentModule()->Exports.emplace_back(Args&: Mod, Args: false);
710 else
711 getCurrentModule()->Imports.insert(X: Mod);
712 } else if (ExportLoc.isValid()) {
713 // [module.interface]p1:
714 // An export-declaration shall inhabit a namespace scope and appear in the
715 // purview of a module interface unit.
716 Diag(Loc: ExportLoc, DiagID: diag::err_export_not_in_module_interface);
717 }
718
719 return Import;
720}
721
722void Sema::ActOnAnnotModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
723 checkModuleImportContext(S&: *this, M: Mod, ImportLoc: DirectiveLoc, DC: CurContext, FromInclude: true);
724 BuildModuleInclude(DirectiveLoc, Mod);
725}
726
727void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
728 // Determine whether we're in the #include buffer for a module. The #includes
729 // in that buffer do not qualify as module imports; they're just an
730 // implementation detail of us building the module.
731 //
732 // FIXME: Should we even get ActOnAnnotModuleInclude calls for those?
733 bool IsInModuleIncludes =
734 TUKind == TU_ClangModule &&
735 getSourceManager().isWrittenInMainFile(Loc: DirectiveLoc);
736
737 // If we are really importing a module (not just checking layering) due to an
738 // #include in the main file, synthesize an ImportDecl.
739 if (getLangOpts().Modules && !IsInModuleIncludes) {
740 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
741 ImportDecl *ImportD = ImportDecl::CreateImplicit(C&: getASTContext(), DC: TU,
742 StartLoc: DirectiveLoc, Imported: Mod,
743 EndLoc: DirectiveLoc);
744 if (!ModuleScopes.empty())
745 Context.addModuleInitializer(M: ModuleScopes.back().Module, Init: ImportD);
746 TU->addDecl(D: ImportD);
747 Consumer.HandleImplicitImportDecl(D: ImportD);
748 }
749
750 getModuleLoader().makeModuleVisible(Mod, Visibility: Module::AllVisible, ImportLoc: DirectiveLoc);
751 VisibleModules.setVisible(M: Mod, Loc: DirectiveLoc);
752
753 if (getLangOpts().isCompilingModule()) {
754 Module *ThisModule = PP.getHeaderSearchInfo().lookupModule(
755 ModuleName: getLangOpts().CurrentModule, ImportLoc: DirectiveLoc, AllowSearch: false, AllowExtraModuleMapSearch: false);
756 (void)ThisModule;
757 assert(ThisModule && "was expecting a module if building one");
758 }
759}
760
761void Sema::ActOnAnnotModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
762 checkModuleImportContext(S&: *this, M: Mod, ImportLoc: DirectiveLoc, DC: CurContext, FromInclude: true);
763
764 ModuleScopes.push_back(Elt: {});
765 ModuleScopes.back().Module = Mod;
766 if (getLangOpts().ModulesLocalVisibility)
767 ModuleScopes.back().OuterVisibleModules = std::move(VisibleModules);
768
769 VisibleModules.setVisible(M: Mod, Loc: DirectiveLoc);
770
771 // The enclosing context is now part of this module.
772 // FIXME: Consider creating a child DeclContext to hold the entities
773 // lexically within the module.
774 if (getLangOpts().trackLocalOwningModule()) {
775 for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
776 cast<Decl>(Val: DC)->setModuleOwnershipKind(
777 getLangOpts().ModulesLocalVisibility
778 ? Decl::ModuleOwnershipKind::VisibleWhenImported
779 : Decl::ModuleOwnershipKind::Visible);
780 cast<Decl>(Val: DC)->setLocalOwningModule(Mod);
781 }
782 }
783}
784
785void Sema::ActOnAnnotModuleEnd(SourceLocation EomLoc, Module *Mod) {
786 if (getLangOpts().ModulesLocalVisibility) {
787 VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
788 // Leaving a module hides namespace names, so our visible namespace cache
789 // is now out of date.
790 VisibleNamespaceCache.clear();
791 }
792
793 assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
794 "left the wrong module scope");
795 ModuleScopes.pop_back();
796
797 // We got to the end of processing a local module. Create an
798 // ImportDecl as we would for an imported module.
799 FileID File = getSourceManager().getFileID(SpellingLoc: EomLoc);
800 SourceLocation DirectiveLoc;
801 if (EomLoc == getSourceManager().getLocForEndOfFile(FID: File)) {
802 // We reached the end of a #included module header. Use the #include loc.
803 assert(File != getSourceManager().getMainFileID() &&
804 "end of submodule in main source file");
805 DirectiveLoc = getSourceManager().getIncludeLoc(FID: File);
806 } else {
807 // We reached an EOM pragma. Use the pragma location.
808 DirectiveLoc = EomLoc;
809 }
810 BuildModuleInclude(DirectiveLoc, Mod);
811
812 // Any further declarations are in whatever module we returned to.
813 if (getLangOpts().trackLocalOwningModule()) {
814 // The parser guarantees that this is the same context that we entered
815 // the module within.
816 for (auto *DC = CurContext; DC; DC = DC->getLexicalParent()) {
817 cast<Decl>(Val: DC)->setLocalOwningModule(getCurrentModule());
818 if (!getCurrentModule())
819 cast<Decl>(Val: DC)->setModuleOwnershipKind(
820 Decl::ModuleOwnershipKind::Unowned);
821 }
822 }
823}
824
825void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
826 Module *Mod) {
827 // Bail if we're not allowed to implicitly import a module here.
828 if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery ||
829 VisibleModules.isVisible(M: Mod))
830 return;
831
832 // Create the implicit import declaration.
833 TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
834 ImportDecl *ImportD = ImportDecl::CreateImplicit(C&: getASTContext(), DC: TU,
835 StartLoc: Loc, Imported: Mod, EndLoc: Loc);
836 TU->addDecl(D: ImportD);
837 Consumer.HandleImplicitImportDecl(D: ImportD);
838
839 // Make the module visible.
840 getModuleLoader().makeModuleVisible(Mod, Visibility: Module::AllVisible, ImportLoc: Loc);
841 VisibleModules.setVisible(M: Mod, Loc);
842}
843
844Decl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
845 SourceLocation LBraceLoc) {
846 ExportDecl *D = ExportDecl::Create(C&: Context, DC: CurContext, ExportLoc);
847
848 // Set this temporarily so we know the export-declaration was braced.
849 D->setRBraceLoc(LBraceLoc);
850
851 CurContext->addDecl(D);
852 PushDeclContext(S, DC: D);
853
854 // C++2a [module.interface]p1:
855 // An export-declaration shall appear only [...] in the purview of a module
856 // interface unit. An export-declaration shall not appear directly or
857 // indirectly within [...] a private-module-fragment.
858 if (!getLangOpts().HLSL) {
859 if (!isCurrentModulePurview()) {
860 Diag(Loc: ExportLoc, DiagID: diag::err_export_not_in_module_interface) << 0;
861 D->setInvalidDecl();
862 return D;
863 } else if (currentModuleIsImplementation()) {
864 Diag(Loc: ExportLoc, DiagID: diag::err_export_not_in_module_interface) << 1;
865 Diag(Loc: ModuleScopes.back().BeginLoc,
866 DiagID: diag::note_not_module_interface_add_export)
867 << FixItHint::CreateInsertion(InsertionLoc: ModuleScopes.back().BeginLoc, Code: "export ");
868 D->setInvalidDecl();
869 return D;
870 } else if (ModuleScopes.back().Module->Kind ==
871 Module::PrivateModuleFragment) {
872 Diag(Loc: ExportLoc, DiagID: diag::err_export_in_private_module_fragment);
873 Diag(Loc: ModuleScopes.back().BeginLoc, DiagID: diag::note_private_module_fragment);
874 D->setInvalidDecl();
875 return D;
876 }
877 }
878
879 for (const DeclContext *DC = CurContext; DC; DC = DC->getLexicalParent()) {
880 if (const auto *ND = dyn_cast<NamespaceDecl>(Val: DC)) {
881 // An export-declaration shall not appear directly or indirectly within
882 // an unnamed namespace [...]
883 if (ND->isAnonymousNamespace()) {
884 Diag(Loc: ExportLoc, DiagID: diag::err_export_within_anonymous_namespace);
885 Diag(Loc: ND->getLocation(), DiagID: diag::note_anonymous_namespace);
886 // Don't diagnose internal-linkage declarations in this region.
887 D->setInvalidDecl();
888 return D;
889 }
890
891 // A declaration is exported if it is [...] a namespace-definition
892 // that contains an exported declaration.
893 //
894 // Defer exporting the namespace until after we leave it, in order to
895 // avoid marking all subsequent declarations in the namespace as exported.
896 if (!getLangOpts().HLSL && !DeferredExportedNamespaces.insert(Ptr: ND).second)
897 break;
898 }
899 }
900
901 // [...] its declaration or declaration-seq shall not contain an
902 // export-declaration.
903 if (auto *ED = getEnclosingExportDecl(D)) {
904 Diag(Loc: ExportLoc, DiagID: diag::err_export_within_export);
905 if (ED->hasBraces())
906 Diag(Loc: ED->getLocation(), DiagID: diag::note_export);
907 D->setInvalidDecl();
908 return D;
909 }
910
911 if (!getLangOpts().HLSL)
912 D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::VisibleWhenImported);
913
914 return D;
915}
916
917static bool checkExportedDecl(Sema &, Decl *, SourceLocation);
918
919/// Check that it's valid to export all the declarations in \p DC.
920static bool checkExportedDeclContext(Sema &S, DeclContext *DC,
921 SourceLocation BlockStart) {
922 bool AllUnnamed = true;
923 for (auto *D : DC->decls())
924 AllUnnamed &= checkExportedDecl(S, D, BlockStart);
925 return AllUnnamed;
926}
927
928/// Check that it's valid to export \p D.
929static bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {
930
931 // HLSL: export declaration is valid only on functions
932 if (S.getLangOpts().HLSL) {
933 // Export-within-export was already diagnosed in ActOnStartExportDecl
934 if (!dyn_cast<FunctionDecl>(Val: D) && !dyn_cast<ExportDecl>(Val: D)) {
935 S.Diag(Loc: D->getBeginLoc(), DiagID: diag::err_hlsl_export_not_on_function);
936 D->setInvalidDecl();
937 return false;
938 }
939 }
940
941 // C++20 [module.interface]p3:
942 // [...] it shall not declare a name with internal linkage.
943 bool HasName = false;
944 if (auto *ND = dyn_cast<NamedDecl>(Val: D)) {
945 // Don't diagnose anonymous union objects; we'll diagnose their members
946 // instead.
947 HasName = (bool)ND->getDeclName();
948 if (HasName && ND->getFormalLinkage() == Linkage::Internal) {
949 S.Diag(Loc: ND->getLocation(), DiagID: diag::err_export_internal) << ND;
950 if (BlockStart.isValid())
951 S.Diag(Loc: BlockStart, DiagID: diag::note_export);
952 return false;
953 }
954 }
955
956 // C++2a [module.interface]p5:
957 // all entities to which all of the using-declarators ultimately refer
958 // shall have been introduced with a name having external linkage
959 if (auto *USD = dyn_cast<UsingShadowDecl>(Val: D)) {
960 NamedDecl *Target = USD->getUnderlyingDecl();
961 Linkage Lk = Target->getFormalLinkage();
962 if (Lk == Linkage::Internal || Lk == Linkage::Module) {
963 S.Diag(Loc: USD->getLocation(), DiagID: diag::err_export_using_internal)
964 << (Lk == Linkage::Internal ? 0 : 1) << Target;
965 S.Diag(Loc: Target->getLocation(), DiagID: diag::note_using_decl_target);
966 if (BlockStart.isValid())
967 S.Diag(Loc: BlockStart, DiagID: diag::note_export);
968 return false;
969 }
970 }
971
972 // Recurse into namespace-scope DeclContexts. (Only namespace-scope
973 // declarations are exported).
974 if (auto *DC = dyn_cast<DeclContext>(Val: D)) {
975 if (!isa<NamespaceDecl>(Val: D))
976 return true;
977
978 if (auto *ND = dyn_cast<NamedDecl>(Val: D)) {
979 if (!ND->getDeclName()) {
980 S.Diag(Loc: ND->getLocation(), DiagID: diag::err_export_anon_ns_internal);
981 if (BlockStart.isValid())
982 S.Diag(Loc: BlockStart, DiagID: diag::note_export);
983 return false;
984 } else if (!DC->decls().empty() &&
985 DC->getRedeclContext()->isFileContext()) {
986 return checkExportedDeclContext(S, DC, BlockStart);
987 }
988 }
989 }
990 return true;
991}
992
993Decl *Sema::ActOnFinishExportDecl(Scope *S, Decl *D, SourceLocation RBraceLoc) {
994 auto *ED = cast<ExportDecl>(Val: D);
995 if (RBraceLoc.isValid())
996 ED->setRBraceLoc(RBraceLoc);
997
998 PopDeclContext();
999
1000 if (!D->isInvalidDecl()) {
1001 SourceLocation BlockStart =
1002 ED->hasBraces() ? ED->getBeginLoc() : SourceLocation();
1003 for (auto *Child : ED->decls()) {
1004 checkExportedDecl(S&: *this, D: Child, BlockStart);
1005 if (auto *FD = dyn_cast<FunctionDecl>(Val: Child)) {
1006 // [dcl.inline]/7
1007 // If an inline function or variable that is attached to a named module
1008 // is declared in a definition domain, it shall be defined in that
1009 // domain.
1010 // So, if the current declaration does not have a definition, we must
1011 // check at the end of the TU (or when the PMF starts) to see that we
1012 // have a definition at that point.
1013 if (FD->isInlineSpecified() && !FD->isDefined())
1014 PendingInlineFuncDecls.insert(Ptr: FD);
1015 }
1016 }
1017 }
1018
1019 // Anything exported from a module should never be considered unused.
1020 for (auto *Exported : ED->decls())
1021 Exported->markUsed(C&: getASTContext());
1022
1023 return D;
1024}
1025
1026Module *Sema::PushGlobalModuleFragment(SourceLocation BeginLoc) {
1027 // We shouldn't create new global module fragment if there is already
1028 // one.
1029 if (!TheGlobalModuleFragment) {
1030 ModuleMap &Map = PP.getHeaderSearchInfo().getModuleMap();
1031 TheGlobalModuleFragment = Map.createGlobalModuleFragmentForModuleUnit(
1032 Loc: BeginLoc, Parent: getCurrentModule());
1033 }
1034
1035 assert(TheGlobalModuleFragment && "module creation should not fail");
1036
1037 // Enter the scope of the global module.
1038 ModuleScopes.push_back(Elt: {.BeginLoc: BeginLoc, .Module: TheGlobalModuleFragment,
1039 /*OuterVisibleModules=*/{}});
1040 VisibleModules.setVisible(M: TheGlobalModuleFragment, Loc: BeginLoc);
1041
1042 return TheGlobalModuleFragment;
1043}
1044
1045void Sema::PopGlobalModuleFragment() {
1046 assert(!ModuleScopes.empty() &&
1047 getCurrentModule()->isExplicitGlobalModule() &&
1048 "left the wrong module scope, which is not global module fragment");
1049 ModuleScopes.pop_back();
1050}
1051
1052Module *Sema::PushImplicitGlobalModuleFragment(SourceLocation BeginLoc) {
1053 if (!TheImplicitGlobalModuleFragment) {
1054 ModuleMap &Map = PP.getHeaderSearchInfo().getModuleMap();
1055 TheImplicitGlobalModuleFragment =
1056 Map.createImplicitGlobalModuleFragmentForModuleUnit(Loc: BeginLoc,
1057 Parent: getCurrentModule());
1058 }
1059 assert(TheImplicitGlobalModuleFragment && "module creation should not fail");
1060
1061 // Enter the scope of the global module.
1062 ModuleScopes.push_back(Elt: {.BeginLoc: BeginLoc, .Module: TheImplicitGlobalModuleFragment,
1063 /*OuterVisibleModules=*/{}});
1064 VisibleModules.setVisible(M: TheImplicitGlobalModuleFragment, Loc: BeginLoc);
1065 return TheImplicitGlobalModuleFragment;
1066}
1067
1068void Sema::PopImplicitGlobalModuleFragment() {
1069 assert(!ModuleScopes.empty() &&
1070 getCurrentModule()->isImplicitGlobalModule() &&
1071 "left the wrong module scope, which is not global module fragment");
1072 ModuleScopes.pop_back();
1073}
1074
1075bool Sema::isCurrentModulePurview() const {
1076 if (!getCurrentModule())
1077 return false;
1078
1079 /// Does this Module scope describe part of the purview of a standard named
1080 /// C++ module?
1081 switch (getCurrentModule()->Kind) {
1082 case Module::ModuleInterfaceUnit:
1083 case Module::ModuleImplementationUnit:
1084 case Module::ModulePartitionInterface:
1085 case Module::ModulePartitionImplementation:
1086 case Module::PrivateModuleFragment:
1087 case Module::ImplicitGlobalModuleFragment:
1088 return true;
1089 default:
1090 return false;
1091 }
1092}
1093