clang 22.0.0git
Module.cpp
Go to the documentation of this file.
1//===- Module.cpp - Describe a module -------------------------------------===//
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 defines the Module class, which describes a module in the source
10// code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Basic/Module.h"
20#include "llvm/ADT/ArrayRef.h"
21#include "llvm/ADT/SmallVector.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/ADT/StringSwitch.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/raw_ostream.h"
28#include <cassert>
29#include <functional>
30#include <string>
31#include <utility>
32#include <vector>
33
34using namespace clang;
35
36Module::Module(ModuleConstructorTag, StringRef Name,
37 SourceLocation DefinitionLoc, Module *Parent, bool IsFramework,
38 bool IsExplicit, unsigned VisibilityID)
39 : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
40 VisibilityID(VisibilityID), IsUnimportable(false),
41 HasIncompatibleModuleFile(false), IsAvailable(true),
42 IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(IsExplicit),
43 IsSystem(false), IsExternC(false), IsInferred(false),
44 InferSubmodules(false), InferExplicitSubmodules(false),
45 InferExportWildcard(false), ConfigMacrosExhaustive(false),
46 NoUndeclaredIncludes(false), ModuleMapIsPrivate(false),
47 NamedModuleHasInit(true), NameVisibility(Hidden) {
48 if (Parent) {
55
56 Parent->SubModules.push_back(this);
57 }
58}
59
60Module::~Module() = default;
61
62static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature) {
63 StringRef Platform = Target.getPlatformName();
64 StringRef Env = Target.getTriple().getEnvironmentName();
65
66 // Attempt to match platform and environment.
67 if (Platform == Feature || Target.getTriple().getOSName() == Feature ||
68 Env == Feature)
69 return true;
70
71 auto CmpPlatformEnv = [](StringRef LHS, StringRef RHS) {
72 auto Pos = LHS.find('-');
73 if (Pos == StringRef::npos)
74 return false;
75 SmallString<128> NewLHS = LHS.slice(0, Pos);
76 NewLHS += LHS.slice(Pos+1, LHS.size());
77 return NewLHS == RHS;
78 };
79
80 SmallString<128> PlatformEnv = Target.getTriple().getOSAndEnvironmentName();
81 // Darwin has different but equivalent variants for simulators, example:
82 // 1. x86_64-apple-ios-simulator
83 // 2. x86_64-apple-iossimulator
84 // where both are valid examples of the same platform+environment but in the
85 // variant (2) the simulator is hardcoded as part of the platform name. Both
86 // forms above should match for "iossimulator" requirement.
87 if (Target.getTriple().isOSDarwin() && PlatformEnv.ends_with("simulator"))
88 return PlatformEnv == Feature || CmpPlatformEnv(PlatformEnv, Feature);
89
90 return PlatformEnv == Feature;
91}
92
93/// Determine whether a translation unit built using the current
94/// language options has the given feature.
95static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
96 const TargetInfo &Target) {
97 bool HasFeature = llvm::StringSwitch<bool>(Feature)
98 .Case("altivec", LangOpts.AltiVec)
99 .Case("blocks", LangOpts.Blocks)
100 .Case("coroutines", LangOpts.Coroutines)
101 .Case("cplusplus", LangOpts.CPlusPlus)
102 .Case("cplusplus11", LangOpts.CPlusPlus11)
103 .Case("cplusplus14", LangOpts.CPlusPlus14)
104 .Case("cplusplus17", LangOpts.CPlusPlus17)
105 .Case("cplusplus20", LangOpts.CPlusPlus20)
106 .Case("cplusplus23", LangOpts.CPlusPlus23)
107 .Case("cplusplus26", LangOpts.CPlusPlus26)
108 .Case("c99", LangOpts.C99)
109 .Case("c11", LangOpts.C11)
110 .Case("c17", LangOpts.C17)
111 .Case("c23", LangOpts.C23)
112 .Case("freestanding", LangOpts.Freestanding)
113 .Case("gnuinlineasm", LangOpts.GNUAsm)
114 .Case("objc", LangOpts.ObjC)
115 .Case("objc_arc", LangOpts.ObjCAutoRefCount)
116 .Case("opencl", LangOpts.OpenCL)
117 .Case("tls", Target.isTLSSupported())
118 .Case("zvector", LangOpts.ZVector)
119 .Default(Target.hasFeature(Feature) ||
121 if (!HasFeature)
122 HasFeature = llvm::is_contained(LangOpts.ModuleFeatures, Feature);
123 return HasFeature;
124}
125
127 const TargetInfo &Target, Requirement &Req,
128 Module *&ShadowingModule) const {
129 if (!IsUnimportable)
130 return false;
131
132 for (const Module *Current = this; Current; Current = Current->Parent) {
133 if (Current->ShadowingModule) {
134 ShadowingModule = Current->ShadowingModule;
135 return true;
136 }
137 for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
138 if (hasFeature(Current->Requirements[I].FeatureName, LangOpts, Target) !=
139 Current->Requirements[I].RequiredState) {
140 Req = Current->Requirements[I];
141 return true;
142 }
143 }
144 }
145
146 llvm_unreachable("could not find a reason why module is unimportable");
147}
148
149// The -fmodule-name option tells the compiler to textually include headers in
150// the specified module, meaning Clang won't build the specified module. This
151// is useful in a number of situations, for instance, when building a library
152// that vends a module map, one might want to avoid hitting intermediate build
153// products containing the module map or avoid finding the system installed
154// modulemap for that library.
155bool Module::isForBuilding(const LangOptions &LangOpts) const {
156 StringRef TopLevelName = getTopLevelModuleName();
157 StringRef CurrentModule = LangOpts.CurrentModule;
158
159 // When building the implementation of framework Foo, we want to make sure
160 // that Foo *and* Foo_Private are textually included and no modules are built
161 // for either.
162 if (!LangOpts.isCompilingModule() && getTopLevelModule()->IsFramework &&
163 CurrentModule == LangOpts.ModuleName &&
164 !CurrentModule.ends_with("_Private") &&
165 TopLevelName.ends_with("_Private"))
166 TopLevelName = TopLevelName.drop_back(8);
167
168 return TopLevelName == CurrentModule;
169}
170
172 Requirement &Req,
173 UnresolvedHeaderDirective &MissingHeader,
174 Module *&ShadowingModule) const {
175 if (IsAvailable)
176 return true;
177
178 if (isUnimportable(LangOpts, Target, Req, ShadowingModule))
179 return false;
180
181 // FIXME: All missing headers are listed on the top-level module. Should we
182 // just look there?
183 for (const Module *Current = this; Current; Current = Current->Parent) {
184 if (!Current->MissingHeaders.empty()) {
185 MissingHeader = Current->MissingHeaders.front();
186 return false;
187 }
188 }
189
190 llvm_unreachable("could not find a reason why module is unavailable");
191}
192
194 for (auto *Parent = this; Parent; Parent = Parent->Parent) {
195 if (Parent == Other)
196 return true;
197 }
198 return false;
199}
200
202 const Module *Result = this;
203 while (Result->Parent)
204 Result = Result->Parent;
205
206 return Result;
207}
208
210 const std::pair<std::string, SourceLocation> &IdComponent) {
211 return IdComponent.first;
212}
213
214static StringRef getModuleNameFromComponent(StringRef R) { return R; }
215
216template<typename InputIter>
217static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End,
218 bool AllowStringLiterals = true) {
219 for (InputIter It = Begin; It != End; ++It) {
220 if (It != Begin)
221 OS << ".";
222
223 StringRef Name = getModuleNameFromComponent(*It);
224 if (!AllowStringLiterals || isValidAsciiIdentifier(Name))
225 OS << Name;
226 else {
227 OS << '"';
228 OS.write_escaped(Name);
229 OS << '"';
230 }
231 }
232}
233
234template<typename Container>
235static void printModuleId(raw_ostream &OS, const Container &C) {
236 return printModuleId(OS, C.begin(), C.end());
237}
238
239std::string Module::getFullModuleName(bool AllowStringLiterals) const {
241
242 // Build up the set of module names (from innermost to outermost).
243 for (const Module *M = this; M; M = M->Parent)
244 Names.push_back(M->Name);
245
246 std::string Result;
247
248 llvm::raw_string_ostream Out(Result);
249 printModuleId(Out, Names.rbegin(), Names.rend(), AllowStringLiterals);
250
251 return Result;
252}
253
255 for (const Module *M = this; M; M = M->Parent) {
256 if (nameParts.empty() || M->Name != nameParts.back())
257 return false;
258 nameParts = nameParts.drop_back();
259 }
260 return nameParts.empty();
261}
262
264 if (const auto *Hdr = std::get_if<FileEntryRef>(&Umbrella))
265 return Hdr->getDir();
266 if (const auto *Dir = std::get_if<DirectoryEntryRef>(&Umbrella))
267 return *Dir;
268 return std::nullopt;
269}
270
272 assert(File);
273 TopHeaders.insert(File);
274}
275
277 if (!TopHeaderNames.empty()) {
278 for (StringRef TopHeaderName : TopHeaderNames)
279 if (auto FE = FileMgr.getOptionalFileRef(TopHeaderName))
280 TopHeaders.insert(*FE);
281 TopHeaderNames.clear();
282 }
283
284 return llvm::ArrayRef(TopHeaders.begin(), TopHeaders.end());
285}
286
287bool Module::directlyUses(const Module *Requested) {
288 auto *Top = getTopLevelModule();
289
290 // A top-level module implicitly uses itself.
291 if (Requested->isSubModuleOf(Top))
292 return true;
293
294 for (auto *Use : Top->DirectUses)
295 if (Requested->isSubModuleOf(Use))
296 return true;
297
298 // Anyone is allowed to use our builtin stddef.h and its accompanying modules.
299 if (Requested->fullModuleNameIs({"_Builtin_stddef", "max_align_t"}) ||
300 Requested->fullModuleNameIs({"_Builtin_stddef_wint_t"}))
301 return true;
302 // Darwin is allowed is to use our builtin 'ptrauth.h' and its accompanying
303 // module.
304 if (!Requested->Parent && Requested->Name == "ptrauth")
305 return true;
306
308 UndeclaredUses.insert(Requested);
309
310 return false;
311}
312
313void Module::addRequirement(StringRef Feature, bool RequiredState,
314 const LangOptions &LangOpts,
315 const TargetInfo &Target) {
316 Requirements.push_back(Requirement{std::string(Feature), RequiredState});
317
318 // If this feature is currently available, we're done.
319 if (hasFeature(Feature, LangOpts, Target) == RequiredState)
320 return;
321
322 markUnavailable(/*Unimportable*/true);
323}
324
325void Module::markUnavailable(bool Unimportable) {
326 auto needUpdate = [Unimportable](Module *M) {
327 return M->IsAvailable || (!M->IsUnimportable && Unimportable);
328 };
329
330 if (!needUpdate(this))
331 return;
332
334 Stack.push_back(this);
335 while (!Stack.empty()) {
336 Module *Current = Stack.pop_back_val();
337
338 if (!needUpdate(Current))
339 continue;
340
341 Current->IsAvailable = false;
342 Current->IsUnimportable |= Unimportable;
343 for (auto *Submodule : Current->submodules()) {
344 if (needUpdate(Submodule))
345 Stack.push_back(Submodule);
346 }
347 }
348}
349
350Module *Module::findSubmodule(StringRef Name) const {
351 // Add new submodules into the index.
352 for (unsigned I = SubModuleIndex.size(), E = SubModules.size(); I != E; ++I)
353 SubModuleIndex[SubModules[I]->Name] = I;
354
355 if (auto It = SubModuleIndex.find(Name); It != SubModuleIndex.end())
356 return SubModules[It->second];
357
358 return nullptr;
359}
360
362 assert(isNamedModuleUnit() && "We should only query the global module "
363 "fragment from the C++20 Named modules");
364
365 for (auto *SubModule : SubModules)
366 if (SubModule->isExplicitGlobalModule())
367 return SubModule;
368
369 return nullptr;
370}
371
373 assert(isNamedModuleUnit() && "We should only query the private module "
374 "fragment from the C++20 Named modules");
375
376 for (auto *SubModule : SubModules)
377 if (SubModule->isPrivateModule())
378 return SubModule;
379
380 return nullptr;
381}
382
384 // All non-explicit submodules are exported.
385 for (std::vector<Module *>::const_iterator I = SubModules.begin(),
386 E = SubModules.end();
387 I != E; ++I) {
388 Module *Mod = *I;
389 if (!Mod->IsExplicit)
390 Exported.push_back(Mod);
391 }
392
393 // Find re-exported modules by filtering the list of imported modules.
394 bool AnyWildcard = false;
395 bool UnrestrictedWildcard = false;
396 SmallVector<Module *, 4> WildcardRestrictions;
397 for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
398 Module *Mod = Exports[I].getPointer();
399 if (!Exports[I].getInt()) {
400 // Export a named module directly; no wildcards involved.
401 Exported.push_back(Mod);
402
403 continue;
404 }
405
406 // Wildcard export: export all of the imported modules that match
407 // the given pattern.
408 AnyWildcard = true;
409 if (UnrestrictedWildcard)
410 continue;
411
412 if (Module *Restriction = Exports[I].getPointer())
413 WildcardRestrictions.push_back(Restriction);
414 else {
415 WildcardRestrictions.clear();
416 UnrestrictedWildcard = true;
417 }
418 }
419
420 // If there were any wildcards, push any imported modules that were
421 // re-exported by the wildcard restriction.
422 if (!AnyWildcard)
423 return;
424
425 for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
426 Module *Mod = Imports[I];
427 bool Acceptable = UnrestrictedWildcard;
428 if (!Acceptable) {
429 // Check whether this module meets one of the restrictions.
430 for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
431 Module *Restriction = WildcardRestrictions[R];
432 if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
433 Acceptable = true;
434 break;
435 }
436 }
437 }
438
439 if (!Acceptable)
440 continue;
441
442 Exported.push_back(Mod);
443 }
444}
445
446void Module::buildVisibleModulesCache() const {
447 assert(VisibleModulesCache.empty() && "cache does not need building");
448
449 // This module is visible to itself.
450 VisibleModulesCache.insert(this);
451
452 // Every imported module is visible.
453 SmallVector<Module *, 16> Stack(Imports.begin(), Imports.end());
454 while (!Stack.empty()) {
455 Module *CurrModule = Stack.pop_back_val();
456
457 // Every module transitively exported by an imported module is visible.
458 if (VisibleModulesCache.insert(CurrModule).second)
459 CurrModule->getExportedModules(Stack);
460 }
461}
462
463void Module::print(raw_ostream &OS, unsigned Indent, bool Dump) const {
464 OS.indent(Indent);
465 if (IsFramework)
466 OS << "framework ";
467 if (IsExplicit)
468 OS << "explicit ";
469 OS << "module ";
470 printModuleId(OS, &Name, &Name + 1);
471
472 if (IsSystem || IsExternC) {
473 OS.indent(Indent + 2);
474 if (IsSystem)
475 OS << " [system]";
476 if (IsExternC)
477 OS << " [extern_c]";
478 }
479
480 OS << " {\n";
481
482 if (!Requirements.empty()) {
483 OS.indent(Indent + 2);
484 OS << "requires ";
485 for (unsigned I = 0, N = Requirements.size(); I != N; ++I) {
486 if (I)
487 OS << ", ";
488 if (!Requirements[I].RequiredState)
489 OS << "!";
490 OS << Requirements[I].FeatureName;
491 }
492 OS << "\n";
493 }
494
495 if (std::optional<Header> H = getUmbrellaHeaderAsWritten()) {
496 OS.indent(Indent + 2);
497 OS << "umbrella header \"";
498 OS.write_escaped(H->NameAsWritten);
499 OS << "\"\n";
500 } else if (std::optional<DirectoryName> D = getUmbrellaDirAsWritten()) {
501 OS.indent(Indent + 2);
502 OS << "umbrella \"";
503 OS.write_escaped(D->NameAsWritten);
504 OS << "\"\n";
505 }
506
507 if (!ConfigMacros.empty() || ConfigMacrosExhaustive) {
508 OS.indent(Indent + 2);
509 OS << "config_macros ";
511 OS << "[exhaustive]";
512 for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
513 if (I)
514 OS << ", ";
515 OS << ConfigMacros[I];
516 }
517 OS << "\n";
518 }
519
520 struct {
521 StringRef Prefix;
523 } Kinds[] = {{"", HK_Normal},
524 {"textual ", HK_Textual},
525 {"private ", HK_Private},
526 {"private textual ", HK_PrivateTextual},
527 {"exclude ", HK_Excluded}};
528
529 for (auto &K : Kinds) {
530 assert(&K == &Kinds[K.Kind] && "kinds in wrong order");
531 for (auto &H : getHeaders(K.Kind)) {
532 OS.indent(Indent + 2);
533 OS << K.Prefix << "header \"";
534 OS.write_escaped(H.NameAsWritten);
535 OS << "\" { size " << H.Entry.getSize()
536 << " mtime " << H.Entry.getModificationTime() << " }\n";
537 }
538 }
539 for (auto *Unresolved : {&UnresolvedHeaders, &MissingHeaders}) {
540 for (auto &U : *Unresolved) {
541 OS.indent(Indent + 2);
542 OS << Kinds[U.Kind].Prefix << "header \"";
543 OS.write_escaped(U.FileName);
544 OS << "\"";
545 if (U.Size || U.ModTime) {
546 OS << " {";
547 if (U.Size)
548 OS << " size " << *U.Size;
549 if (U.ModTime)
550 OS << " mtime " << *U.ModTime;
551 OS << " }";
552 }
553 OS << "\n";
554 }
555 }
556
557 if (!ExportAsModule.empty()) {
558 OS.indent(Indent + 2);
559 OS << "export_as" << ExportAsModule << "\n";
560 }
561
562 for (auto *Submodule : submodules())
563 // Print inferred subframework modules so that we don't need to re-infer
564 // them (requires expensive directory iteration + stat calls) when we build
565 // the module. Regular inferred submodules are OK, as we need to look at all
566 // those header files anyway.
567 if (!Submodule->IsInferred || Submodule->IsFramework)
568 Submodule->print(OS, Indent + 2, Dump);
569
570 for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
571 OS.indent(Indent + 2);
572 OS << "export ";
573 if (Module *Restriction = Exports[I].getPointer()) {
574 OS << Restriction->getFullModuleName(true);
575 if (Exports[I].getInt())
576 OS << ".*";
577 } else {
578 OS << "*";
579 }
580 OS << "\n";
581 }
582
583 for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
584 OS.indent(Indent + 2);
585 OS << "export ";
587 if (UnresolvedExports[I].Wildcard)
588 OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");
589 OS << "\n";
590 }
591
592 if (Dump) {
593 for (Module *M : Imports) {
594 OS.indent(Indent + 2);
595 llvm::errs() << "import " << M->getFullModuleName() << "\n";
596 }
597 }
598
599 for (unsigned I = 0, N = DirectUses.size(); I != N; ++I) {
600 OS.indent(Indent + 2);
601 OS << "use ";
602 OS << DirectUses[I]->getFullModuleName(true);
603 OS << "\n";
604 }
605
606 for (unsigned I = 0, N = UnresolvedDirectUses.size(); I != N; ++I) {
607 OS.indent(Indent + 2);
608 OS << "use ";
610 OS << "\n";
611 }
612
613 for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
614 OS.indent(Indent + 2);
615 OS << "link ";
617 OS << "framework ";
618 OS << "\"";
619 OS.write_escaped(LinkLibraries[I].Library);
620 OS << "\"";
621 }
622
623 for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
624 OS.indent(Indent + 2);
625 OS << "conflict ";
627 OS << ", \"";
628 OS.write_escaped(UnresolvedConflicts[I].Message);
629 OS << "\"\n";
630 }
631
632 for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
633 OS.indent(Indent + 2);
634 OS << "conflict ";
635 OS << Conflicts[I].Other->getFullModuleName(true);
636 OS << ", \"";
637 OS.write_escaped(Conflicts[I].Message);
638 OS << "\"\n";
639 }
640
641 if (InferSubmodules) {
642 OS.indent(Indent + 2);
644 OS << "explicit ";
645 OS << "module * {\n";
647 OS.indent(Indent + 4);
648 OS << "export *\n";
649 }
650 OS.indent(Indent + 2);
651 OS << "}\n";
652 }
653
654 OS.indent(Indent);
655 OS << "}\n";
656}
657
658LLVM_DUMP_METHOD void Module::dump() const {
659 print(llvm::errs(), 0, true);
660}
661
663 bool IncludeExports, VisibleCallback Vis,
664 ConflictCallback Cb) {
665 // We can't import a global module fragment so the location can be invalid.
666 assert((M->isGlobalModule() || Loc.isValid()) &&
667 "setVisible expects a valid import location");
668 if (isVisible(M))
669 return;
670
671 ++Generation;
672
673 struct Visiting {
674 Module *M;
675 Visiting *ExportedBy;
676 };
677
678 std::function<void(Visiting)> VisitModule = [&](Visiting V) {
679 // Nothing to do for a module that's already visible.
680 unsigned ID = V.M->getVisibilityID();
681 if (ImportLocs.size() <= ID)
682 ImportLocs.resize(ID + 1);
683 else if (ImportLocs[ID].isValid())
684 return;
685
686 ImportLocs[ID] = Loc;
687 Vis(V.M);
688
689 // Make any exported modules visible.
690 if (IncludeExports) {
692 V.M->getExportedModules(Exports);
693 for (Module *E : Exports) {
694 // Don't import non-importable modules.
695 if (!E->isUnimportable())
696 VisitModule({E, &V});
697 }
698 }
699
700 for (auto &C : V.M->Conflicts) {
701 if (isVisible(C.Other)) {
703 for (Visiting *I = &V; I; I = I->ExportedBy)
704 Path.push_back(I->M);
705 Cb(Path, C.Other, C.Message);
706 }
707 }
708 };
709 VisitModule({M, nullptr});
710}
#define V(N, I)
Definition: ASTContext.h:3597
NodeId Parent
Definition: ASTDiff.cpp:191
const Decl * D
IndirectLocalPath & Path
Expr * E
Defines the clang::FileManager interface and associated types.
const Environment & Env
Definition: HTMLLogger.cpp:147
Defines the clang::LangOptions interface.
llvm::MachO::Target Target
Definition: MachO.h:51
static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature)
Definition: Module.cpp:62
static bool hasFeature(StringRef Feature, const LangOptions &LangOpts, const TargetInfo &Target)
Determine whether a translation unit built using the current language options has the given feature.
Definition: Module.cpp:95
static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End, bool AllowStringLiterals=true)
Definition: Module.cpp:217
static StringRef getModuleNameFromComponent(const std::pair< std::string, SourceLocation > &IdComponent)
Definition: Module.cpp:209
Defines the clang::Module class, which describes a module in the source code.
static bool HasFeature(const Preprocessor &PP, StringRef Feature)
HasFeature - Return true if we recognize and implement the feature specified by the identifier as a s...
uint32_t Id
Definition: SemaARM.cpp:1179
SourceLocation Loc
Definition: SemaObjC.cpp:754
Defines the clang::SourceLocation class and associated facilities.
SourceLocation Begin
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Definition: FileEntry.h:57
Implements support for file system lookup, file system caching, and directory search management.
Definition: FileManager.h:53
OptionalFileEntryRef getOptionalFileRef(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Get a FileEntryRef if it exists, without doing anything on error.
Definition: FileManager.h:208
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:434
std::string ModuleName
The module currently being compiled as specified by -fmodule-name.
Definition: LangOptions.h:482
bool isCompilingModule() const
Are we compiling a module?
Definition: LangOptions.h:596
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:489
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:495
Required to construct a Module.
Definition: Module.h:136
Describes a module or submodule.
Definition: Module.h:144
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:732
void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)
Add the given feature requirement to the list of features required by this module.
Definition: Module.cpp:313
unsigned IsExplicit
Whether this is an explicit submodule.
Definition: Module.h:384
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:471
bool isForBuilding(const LangOptions &LangOpts) const
Determine whether this module can be built in this compilation.
Definition: Module.cpp:155
std::variant< std::monostate, FileEntryRef, DirectoryEntryRef > Umbrella
The umbrella header or directory.
Definition: Module.h:205
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:406
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:350
bool directlyUses(const Module *Requested)
Determine whether this module has declared its intention to directly use another module.
Definition: Module.cpp:287
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:528
unsigned IsUnimportable
Whether this module has declared itself unimportable, either because it's missing a requirement from ...
Definition: Module.h:361
void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const
Print the module map for this module to the given stream.
Definition: Module.cpp:463
bool isNamedModuleUnit() const
Is this a C++20 named module unit.
Definition: Module.h:676
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system.
Definition: Module.h:341
Module * Parent
The parent of this module.
Definition: Module.h:193
void markUnavailable(bool Unimportable)
Mark this module and all of its submodules as unavailable.
Definition: Module.cpp:325
SmallVector< UnresolvedHeaderDirective, 1 > UnresolvedHeaders
Headers that are mentioned in the module map file but that we have not yet attempted to resolve to a ...
Definition: Module.h:337
ModuleKind Kind
The kind of this module.
Definition: Module.h:189
@ HK_PrivateTextual
Definition: Module.h:282
bool isUnimportable() const
Determine whether this module has been declared unimportable.
Definition: Module.h:563
bool fullModuleNameIs(ArrayRef< StringRef > nameParts) const
Whether the full name of this module is equal to joining nameParts with "."s.
Definition: Module.cpp:254
Module * getPrivateModuleFragment() const
Get the Private Module Fragment (sub-module) for this module, it there is one.
Definition: Module.cpp:372
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:458
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
Definition: Module.h:389
std::string Name
The name of this module.
Definition: Module.h:147
Module * getGlobalModuleFragment() const
Get the Global Module Fragment (sub-module) for this module, it there is one.
Definition: Module.cpp:361
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:838
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...
Definition: Module.h:395
unsigned ModuleMapIsPrivate
Whether this module came from a "private" module map, found next to a regular (public) module map.
Definition: Module.h:434
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
Definition: Module.h:520
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:489
std::optional< Header > getUmbrellaHeaderAsWritten() const
Retrieve the umbrella header as written.
Definition: Module.h:756
SmallVector< Requirement, 2 > Requirements
The set of language features required to use this module.
Definition: Module.h:352
llvm::SmallSetVector< const Module *, 2 > UndeclaredUses
When NoUndeclaredIncludes is true, the set of modules this module tried to import but didn't because ...
Definition: Module.h:499
SmallVector< ModuleId, 2 > UnresolvedDirectUses
The set of use declarations that have yet to be resolved.
Definition: Module.h:495
unsigned NoUndeclaredIncludes
Whether files in this module can only include non-modular headers and headers from used modules.
Definition: Module.h:429
SmallVector< Module *, 2 > DirectUses
The directly used modules.
Definition: Module.h:492
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:424
ArrayRef< Header > getHeaders(HeaderKind HK) const
Definition: Module.h:302
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
Definition: Module.h:239
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e....
Definition: Module.h:416
void getExportedModules(SmallVectorImpl< Module * > &Exported) const
Appends this module's list of exported modules to Exported.
Definition: Module.cpp:383
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:541
bool isSubModuleOf(const Module *Other) const
Check if this module is a (possibly transitive) submodule of Other.
Definition: Module.cpp:193
ArrayRef< FileEntryRef > getTopHeaders(FileManager &FileMgr)
The top-level headers associated with this module.
Definition: Module.cpp:276
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
Definition: Module.h:586
std::optional< DirectoryName > getUmbrellaDirAsWritten() const
Retrieve the umbrella directory as written.
Definition: Module.h:748
void dump() const
Dump the contents of this module to the given output stream.
Module * ShadowingModule
A module with the same name that shadows this module.
Definition: Module.h:355
unsigned IsFramework
Whether this is a framework module.
Definition: Module.h:380
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed,...
Definition: Module.h:218
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:239
void addTopHeader(FileEntryRef File)
Add a top-level header associated with this module.
Definition: Module.cpp:271
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:372
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:411
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:722
OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const
Get the effective umbrella directory for this module: either the one explicitly written in the module...
Definition: Module.cpp:263
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:553
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
Exposes information about the current target.
Definition: TargetInfo.h:226
llvm::function_ref< void(ArrayRef< Module * > Path, Module *Conflict, StringRef Message)> ConflictCallback
A callback to call when a module conflict is found.
Definition: Module.h:910
void setVisible(Module *M, SourceLocation Loc, bool IncludeExports=true, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module * >, Module *, StringRef) {})
Make a specific module visible.
Definition: Module.cpp:662
llvm::function_ref< void(Module *M)> VisibleCallback
A callback to call when a module is made visible (directly or indirectly) by a call to setVisible.
Definition: Module.h:903
bool isVisible(const Module *M) const
Determine whether a module is visible.
Definition: Module.h:890
Defines the clang::TargetInfo interface.
The JSON file list parser is used to communicate input to InstallAPI.
LLVM_READONLY bool isValidAsciiIdentifier(StringRef S, bool AllowDollar=false)
Return true if this is a valid ASCII identifier.
Definition: CharInfo.h:244
@ Result
The result type of a method or function.
@ Other
Other implicit parameter.
int const char * function
Definition: c++config.h:31
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Module.h:325