14#ifndef LLVM_CLANG_LEX_MODULEMAP_H
15#define LLVM_CLANG_LEX_MODULEMAP_H
21#include "llvm/ADT/ArrayRef.h"
22#include "llvm/ADT/DenseMap.h"
23#include "llvm/ADT/PointerIntPair.h"
24#include "llvm/ADT/SmallPtrSet.h"
25#include "llvm/ADT/SmallVector.h"
26#include "llvm/ADT/StringMap.h"
27#include "llvm/ADT/StringRef.h"
28#include "llvm/ADT/StringSet.h"
29#include "llvm/ADT/TinyPtrVector.h"
30#include "llvm/ADT/Twine.h"
39class DiagnosticsEngine;
49 virtual void anchor();
94 Module *SourceModule =
nullptr;
101 llvm::StringMap<Module *> Modules;
105 llvm::DenseMap<const IdentifierInfo *, Module *> CachedModuleLoads;
111 unsigned NumCreatedModules = 0;
115 llvm::StringMap<llvm::StringSet<>> PendingLinkAsModule;
160 llvm::PointerIntPair<Module *, 3, ModuleHeaderRole> Storage;
167 return A.Storage == B.Storage;
170 return A.Storage != B.Storage;
192 explicit operator bool()
const {
193 return Storage.getPointer() !=
nullptr;
202 using HeadersMap = llvm::DenseMap<FileEntryRef, SmallVector<KnownHeader, 1>>;
209 mutable llvm::DenseMap<off_t, llvm::TinyPtrVector<Module*>> LazyHeadersBySize;
212 mutable llvm::DenseMap<time_t, llvm::TinyPtrVector<Module*>>
213 LazyHeadersByModTime;
221 llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
228 unsigned CurrentModuleScopeID = 0;
230 llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;
235 unsigned IsSystem : 1;
238 unsigned IsExternC : 1;
241 unsigned IsExhaustive : 1;
245 unsigned NoUndeclaredIncludes : 1;
249 NoUndeclaredIncludes(
false) {}
253 struct InferredDirectory {
255 unsigned InferModules : 1;
266 SmallVector<std::string, 2> ExcludedModules;
268 InferredDirectory() : InferModules(
false) {}
273 llvm::DenseMap<const DirectoryEntry *, InferredDirectory> InferredDirectories;
278 llvm::DenseMap<const Module *, OptionalFileEntryRef> InferredModuleAllowedBy;
280 llvm::DenseMap<const Module *, AdditionalModMapsSet> AdditionalModMaps;
284 llvm::DenseMap<const FileEntry *, bool> ParsedModuleMap;
299 resolveExport(Module *Mod,
const Module::UnresolvedExportDecl &
Unresolved,
300 bool Complain)
const;
313 Module *resolveModuleId(
const ModuleId &
Id, Module *Mod,
bool Complain)
const;
322 void addUnresolvedHeader(Module *Mod,
323 Module::UnresolvedHeaderDirective Header,
324 bool &NeedsFramework);
336 findHeader(Module *M,
const Module::UnresolvedHeaderDirective &Header,
337 SmallVectorImpl<char> &RelativePathName,
bool &NeedsFramework);
345 void resolveHeader(Module *M,
const Module::UnresolvedHeaderDirective &Header,
346 bool &NeedsFramework);
351 bool resolveAsBuiltinHeader(Module *M,
352 const Module::UnresolvedHeaderDirective &Header);
359 HeadersMap::iterator findKnownHeader(FileEntryRef
File);
367 KnownHeader findHeaderInUmbrellaDirs(
368 FileEntryRef
File, SmallVectorImpl<DirectoryEntryRef> &IntermediateDirs);
372 KnownHeader findOrCreateModuleForHeaderInUmbrellaDir(FileEntryRef
File);
376 bool isHeaderInUmbrellaDirs(FileEntryRef
File) {
377 SmallVector<DirectoryEntryRef, 2> IntermediateDirs;
378 return static_cast<bool>(findHeaderInUmbrellaDirs(
File, IntermediateDirs));
381 Module *inferFrameworkModule(DirectoryEntryRef FrameworkDir, Attributes Attrs,
396 ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags,
397 const LangOptions &LangOpts,
const TargetInfo *Target,
398 HeaderSearch &HeaderInfo);
404 void setTarget(
const TargetInfo &Target);
409 BuiltinIncludeDir = Dir;
414 return BuiltinIncludeDir;
422 Callbacks.push_back(std::move(Callback));
440 bool AllowExcluded =
false);
465 std::optional<const FileEntry *>
File)
const;
482 bool RequestingModuleIsModuleInterface,
493 const Module *RequestingModule)
const;
601 assert(!ExistingModule->
Parent &&
"expected top-level module");
602 assert(ModuleScopeIDs.count(ExistingModule) &&
"unknown module");
603 return ModuleScopeIDs[ExistingModule] < CurrentModuleScopeID;
608 auto It = InferredDirectories.find(Dir);
609 return It != InferredDirectories.end() && It->getSecond().InferModules;
648 auto I = AdditionalModMaps.find(M);
649 if (I == AdditionalModMaps.end())
689 const Twine &NameAsWritten,
690 const Twine &PathRelativeToRootModuleDirectory);
694 const Twine &NameAsWritten,
695 const Twine &PathRelativeToRootModuleDirectory);
724 unsigned *Offset =
nullptr,
734 llvm::iterator_range<module_iterator>
modules()
const {
740 CachedModuleLoads[&II] = M;
745 auto I = CachedModuleLoads.find(&II);
746 if (I == CachedModuleLoads.end())
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Defines the clang::LangOptions interface.
Defines the clang::Module class, which describes a module in the source code.
Defines the clang::SourceLocation class and associated facilities.
Concrete class used by the front-end to report problems and issues.
A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...
Cached information about one directory (either on disk or in the virtual file system).
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Cached information about one file (either on disk or in the virtual file system).
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
One of these records is kept for each identifier that is lexed.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
A mechanism to observe the actions of the module map parser as it reads module map files.
virtual void moduleMapFileRead(SourceLocation FileStart, FileEntryRef File, bool IsSystem)
Called when a module map file has been read.
virtual ~ModuleMapCallbacks()=default
virtual void moduleMapAddHeader(StringRef Filename)
Called when a header is added during module map parsing.
virtual void moduleMapAddUmbrellaHeader(FileEntryRef Header)
Called when an umbrella header is added during module map parsing.
Module * createShadowedModule(StringRef Name, bool IsFramework, Module *ShadowingModule)
Create a new top-level module that is shadowed by ShadowingModule.
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
void addLinkAsDependency(Module *Mod)
Make module to use export_as as the link dependency name if enough information is available or add it...
void dump()
Dump the contents of the module map, for debugging purposes.
std::pair< Module *, bool > findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)
Find a new module or submodule, or create it if it does not already exist.
llvm::StringMap< Module * >::const_iterator module_iterator
void setUmbrellaDirAsWritten(Module *Mod, DirectoryEntryRef UmbrellaDir, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella directory of the given module to the given directory.
void diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File)
Reports errors if a module must not include a specific file.
void addAdditionalModuleMapFile(const Module *M, FileEntryRef ModuleMap)
OptionalFileEntryRef getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
static Module::HeaderKind headerRoleToKind(ModuleHeaderRole Role)
Convert a header role to a kind.
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
void finishModuleDeclarationScope()
Creates a new declaration scope for module names, allowing previously defined modules to shadow defin...
bool canInferFrameworkModule(const DirectoryEntry *Dir) const
Check whether a framework module can be inferred in the given directory.
bool mayShadowNewModule(Module *ExistingModule)
KnownHeader findModuleForHeader(FileEntryRef File, bool AllowTextual=false, bool AllowExcluded=false)
Retrieve the module that owns the given header file, if any.
Module * createHeaderUnit(SourceLocation Loc, StringRef Name, Module::Header H)
Create a C++20 header unit.
void addModuleMapCallbacks(std::unique_ptr< ModuleMapCallbacks > Callback)
Add a module map callback.
void setBuiltinIncludeDir(DirectoryEntryRef Dir)
Set the directory that contains Clang-supplied include files, such as our stdarg.h or tgmath....
static bool isModular(ModuleHeaderRole Role)
Check if the header with the given role is a modular one.
void setInferredModuleAllowedBy(Module *M, OptionalFileEntryRef ModMap)
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
bool isHeaderUnavailableInModule(FileEntryRef Header, const Module *RequestingModule) const
Determine whether the given header is unavailable as part of the specified module.
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
const DirectoryEntry * getBuiltinDir() const
Get the directory that contains Clang-supplied include files.
module_iterator module_begin() const
ArrayRef< KnownHeader > findResolvedModulesForHeader(FileEntryRef File) const
Like findAllModulesForHeader, but do not attempt to infer module ownership from umbrella headers if w...
OptionalFileEntryRef getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module.
Module * createModuleForImplementationUnit(SourceLocation Loc, StringRef Name)
Create a new module for a C++ module implementation unit.
ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const TargetInfo *Target, HeaderSearch &HeaderInfo)
Construct a new module map.
std::optional< Module * > getCachedModuleLoad(const IdentifierInfo &II)
Return a cached module load.
std::error_code canonicalizeModuleMapPath(SmallVectorImpl< char > &Path)
Canonicalize Path in a manner suitable for a module map file.
void setUmbrellaHeaderAsWritten(Module *Mod, FileEntryRef UmbrellaHeader, const Twine &NameAsWritten, const Twine &PathRelativeToRootModuleDirectory)
Sets the umbrella header of the given module to the given header.
Module * lookupModuleUnqualified(StringRef Name, Module *Context) const
Retrieve a module with the given name using lexical name lookup, starting at the given context.
bool isBuiltinHeader(FileEntryRef File)
Is this a compiler builtin header?
module_iterator module_end() const
AdditionalModMapsSet * getAdditionalModuleMapFiles(const Module *M)
Get any module map files other than getModuleMapFileForUniquing(M) that define submodules of a top-le...
bool isHeaderInUnavailableModule(FileEntryRef Header) const
Determine whether the given header is part of a module marked 'unavailable'.
bool parseModuleMapFile(FileEntryRef File, bool IsSystem, DirectoryEntryRef HomeDir, FileID ID=FileID(), unsigned *Offset=nullptr, SourceLocation ExternModuleLoc=SourceLocation())
Parse the given module map file, and record any modules we encounter.
Module * createImplicitGlobalModuleFragmentForModuleUnit(SourceLocation Loc, bool IsExported, Module *Parent=nullptr)
~ModuleMap()
Destroy the module map.
Module * createGlobalModuleFragmentForModuleUnit(SourceLocation Loc, Module *Parent=nullptr)
Create a global module fragment for a C++ module unit.
void setTarget(const TargetInfo &Target)
Set the target information.
Module * lookupModuleQualified(StringRef Name, Module *Context) const
Retrieve a module with the given name within the given context, using direct (qualified) name lookup.
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
void cacheModuleLoad(const IdentifierInfo &II, Module *M)
Cache a module load. M might be nullptr.
ModuleHeaderRole
Flags describing the role of a module header.
@ PrivateHeader
This header is included but private.
@ ExcludedHeader
This header is explicitly excluded from the module.
@ NormalHeader
This header is normally included in the module.
@ TextualHeader
This header is part of the module (for layering purposes) but should be textually included.
Module * createModuleForInterfaceUnit(SourceLocation Loc, StringRef Name)
Create a new module for a C++ module interface unit.
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Module * createPrivateModuleFragmentForInterfaceUnit(Module *Parent, SourceLocation Loc)
Create a global module fragment for a C++ module interface unit.
ArrayRef< KnownHeader > findAllModulesForHeader(FileEntryRef File)
Retrieve all the modules that contain the given header file.
Module * createModuleUnitWithKind(SourceLocation Loc, StringRef Name, Module::ModuleKind Kind)
Create a new C++ module with the specified kind, and reparent any pending global module fragment(s) t...
static ModuleHeaderRole headerKindToRole(Module::HeaderKind Kind)
Convert a header kind to a role. Requires Kind to not be HK_Excluded.
llvm::iterator_range< module_iterator > modules() const
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Describes a module or submodule.
Module * Parent
The parent of this module.
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Wrapper around OptionalDirectoryEntryRef that degrades to 'const DirectoryEntry*',...
Encodes a location in the source.
This class handles loading and caching of source files into memory.
Exposes information about the current target.
CustomizableOptional< FileEntryRef > OptionalFileEntryRef
SmallVector< std::pair< std::string, SourceLocation >, 2 > ModuleId
Describes the name of a module.