1 //===--- ModuleMap.cpp - Describe the layout of modules ---------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ModuleMap implementation, which describes the layout
11 // of a module as it relates to headers.
13 //===----------------------------------------------------------------------===//
14 #include "clang/Lex/ModuleMap.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticOptions.h"
18 #include "clang/Basic/FileManager.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Basic/TargetOptions.h"
21 #include "clang/Lex/HeaderSearch.h"
22 #include "clang/Lex/HeaderSearchOptions.h"
23 #include "clang/Lex/LexDiagnostic.h"
24 #include "clang/Lex/Lexer.h"
25 #include "clang/Lex/LiteralSupport.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/StringSwitch.h"
28 #include "llvm/Support/Allocator.h"
29 #include "llvm/Support/FileSystem.h"
30 #include "llvm/Support/Host.h"
31 #include "llvm/Support/Path.h"
32 #include "llvm/Support/raw_ostream.h"
34 #if defined(LLVM_ON_UNIX)
37 using namespace clang;
40 ModuleMap::resolveExport(Module *Mod,
41 const Module::UnresolvedExportDecl &Unresolved,
42 bool Complain) const {
43 // We may have just a wildcard.
44 if (Unresolved.Id.empty()) {
45 assert(Unresolved.Wildcard && "Invalid unresolved export");
46 return Module::ExportDecl(nullptr, true);
49 // Resolve the module-id.
50 Module *Context = resolveModuleId(Unresolved.Id, Mod, Complain);
52 return Module::ExportDecl();
54 return Module::ExportDecl(Context, Unresolved.Wildcard);
57 Module *ModuleMap::resolveModuleId(const ModuleId &Id, Module *Mod,
58 bool Complain) const {
59 // Find the starting module.
60 Module *Context = lookupModuleUnqualified(Id[0].first, Mod);
63 Diags.Report(Id[0].second, diag::err_mmap_missing_module_unqualified)
64 << Id[0].first << Mod->getFullModuleName();
69 // Dig into the module path.
70 for (unsigned I = 1, N = Id.size(); I != N; ++I) {
71 Module *Sub = lookupModuleQualified(Id[I].first, Context);
74 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
75 << Id[I].first << Context->getFullModuleName()
76 << SourceRange(Id[0].second, Id[I-1].second);
87 ModuleMap::ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags,
88 const LangOptions &LangOpts, const TargetInfo *Target,
89 HeaderSearch &HeaderInfo)
90 : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target),
91 HeaderInfo(HeaderInfo), BuiltinIncludeDir(nullptr),
92 SourceModule(nullptr), NumCreatedModules(0) {
93 MMapLangOpts.LineComment = true;
96 ModuleMap::~ModuleMap() {
97 for (auto &M : Modules)
101 void ModuleMap::setTarget(const TargetInfo &Target) {
102 assert((!this->Target || this->Target == &Target) &&
103 "Improper target override");
104 this->Target = &Target;
107 /// \brief "Sanitize" a filename so that it can be used as an identifier.
108 static StringRef sanitizeFilenameAsIdentifier(StringRef Name,
109 SmallVectorImpl<char> &Buffer) {
113 if (!isValidIdentifier(Name)) {
114 // If we don't already have something with the form of an identifier,
115 // create a buffer with the sanitized name.
117 if (isDigit(Name[0]))
118 Buffer.push_back('_');
119 Buffer.reserve(Buffer.size() + Name.size());
120 for (unsigned I = 0, N = Name.size(); I != N; ++I) {
121 if (isIdentifierBody(Name[I]))
122 Buffer.push_back(Name[I]);
124 Buffer.push_back('_');
127 Name = StringRef(Buffer.data(), Buffer.size());
130 while (llvm::StringSwitch<bool>(Name)
131 #define KEYWORD(Keyword,Conditions) .Case(#Keyword, true)
132 #define ALIAS(Keyword, AliasOf, Conditions) .Case(Keyword, true)
133 #include "clang/Basic/TokenKinds.def"
135 if (Name.data() != Buffer.data())
136 Buffer.append(Name.begin(), Name.end());
137 Buffer.push_back('_');
138 Name = StringRef(Buffer.data(), Buffer.size());
144 /// \brief Determine whether the given file name is the name of a builtin
145 /// header, supplied by Clang to replace, override, or augment existing system
147 bool ModuleMap::isBuiltinHeader(StringRef FileName) {
148 return llvm::StringSwitch<bool>(FileName)
149 .Case("float.h", true)
150 .Case("iso646.h", true)
151 .Case("limits.h", true)
152 .Case("stdalign.h", true)
153 .Case("stdarg.h", true)
154 .Case("stdatomic.h", true)
155 .Case("stdbool.h", true)
156 .Case("stddef.h", true)
157 .Case("stdint.h", true)
158 .Case("tgmath.h", true)
159 .Case("unwind.h", true)
163 ModuleMap::HeadersMap::iterator
164 ModuleMap::findKnownHeader(const FileEntry *File) {
165 HeadersMap::iterator Known = Headers.find(File);
166 if (HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps &&
167 Known == Headers.end() && File->getDir() == BuiltinIncludeDir &&
168 ModuleMap::isBuiltinHeader(llvm::sys::path::filename(File->getName()))) {
169 HeaderInfo.loadTopLevelSystemModules();
170 return Headers.find(File);
175 ModuleMap::KnownHeader
176 ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File,
177 SmallVectorImpl<const DirectoryEntry *> &IntermediateDirs) {
178 if (UmbrellaDirs.empty())
179 return KnownHeader();
181 const DirectoryEntry *Dir = File->getDir();
182 assert(Dir && "file in no directory");
184 // Note: as an egregious but useful hack we use the real path here, because
185 // frameworks moving from top-level frameworks to embedded frameworks tend
186 // to be symlinked from the top-level location to the embedded location,
187 // and we need to resolve lookups as if we had found the embedded location.
188 StringRef DirName = SourceMgr.getFileManager().getCanonicalName(Dir);
190 // Keep walking up the directory hierarchy, looking for a directory with
191 // an umbrella header.
193 auto KnownDir = UmbrellaDirs.find(Dir);
194 if (KnownDir != UmbrellaDirs.end())
195 return KnownHeader(KnownDir->second, NormalHeader);
197 IntermediateDirs.push_back(Dir);
199 // Retrieve our parent path.
200 DirName = llvm::sys::path::parent_path(DirName);
204 // Resolve the parent path to a directory entry.
205 Dir = SourceMgr.getFileManager().getDirectory(DirName);
207 return KnownHeader();
210 static bool violatesPrivateInclude(Module *RequestingModule,
211 const FileEntry *IncFileEnt,
212 ModuleMap::KnownHeader Header) {
214 if (Header.getRole() & ModuleMap::PrivateHeader) {
215 // Check for consistency between the module header role
216 // as obtained from the lookup and as obtained from the module.
217 // This check is not cheap, so enable it only for debugging.
218 bool IsPrivate = false;
219 SmallVectorImpl<Module::Header> *HeaderList[] = {
220 &Header.getModule()->Headers[Module::HK_Private],
221 &Header.getModule()->Headers[Module::HK_PrivateTextual]};
222 for (auto *Hs : HeaderList)
224 std::find_if(Hs->begin(), Hs->end(), [&](const Module::Header &H) {
225 return H.Entry == IncFileEnt;
227 assert(IsPrivate && "inconsistent headers and roles");
230 return !Header.isAccessibleFrom(RequestingModule);
233 static Module *getTopLevelOrNull(Module *M) {
234 return M ? M->getTopLevelModule() : nullptr;
237 void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule,
238 bool RequestingModuleIsModuleInterface,
239 SourceLocation FilenameLoc,
241 const FileEntry *File) {
242 // No errors for indirect modules. This may be a bit of a problem for modules
243 // with no source files.
244 if (getTopLevelOrNull(RequestingModule) != getTopLevelOrNull(SourceModule))
247 if (RequestingModule)
248 resolveUses(RequestingModule, /*Complain=*/false);
250 bool Excluded = false;
251 Module *Private = nullptr;
252 Module *NotUsed = nullptr;
254 HeadersMap::iterator Known = findKnownHeader(File);
255 if (Known != Headers.end()) {
256 for (const KnownHeader &Header : Known->second) {
257 // Remember private headers for later printing of a diagnostic.
258 if (violatesPrivateInclude(RequestingModule, File, Header)) {
259 Private = Header.getModule();
263 // If uses need to be specified explicitly, we are only allowed to return
264 // modules that are explicitly used by the requesting module.
265 if (RequestingModule && LangOpts.ModulesDeclUse &&
266 !RequestingModule->directlyUses(Header.getModule())) {
267 NotUsed = Header.getModule();
271 // We have found a module that we can happily use.
278 // We have found a header, but it is private.
280 Diags.Report(FilenameLoc, diag::warn_use_of_private_header_outside_module)
285 // We have found a module, but we don't use it.
287 Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
288 << RequestingModule->getFullModuleName() << Filename;
292 if (Excluded || isHeaderInUmbrellaDirs(File))
295 // At this point, only non-modular includes remain.
297 if (LangOpts.ModulesStrictDeclUse) {
298 Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
299 << RequestingModule->getFullModuleName() << Filename;
300 } else if (RequestingModule && RequestingModuleIsModuleInterface &&
301 LangOpts.isCompilingModule()) {
302 // Do not diagnose when we are not compiling a module.
303 diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ?
304 diag::warn_non_modular_include_in_framework_module :
305 diag::warn_non_modular_include_in_module;
306 Diags.Report(FilenameLoc, DiagID) << RequestingModule->getFullModuleName()
311 static bool isBetterKnownHeader(const ModuleMap::KnownHeader &New,
312 const ModuleMap::KnownHeader &Old) {
313 // Prefer available modules.
314 if (New.getModule()->isAvailable() && !Old.getModule()->isAvailable())
317 // Prefer a public header over a private header.
318 if ((New.getRole() & ModuleMap::PrivateHeader) !=
319 (Old.getRole() & ModuleMap::PrivateHeader))
320 return !(New.getRole() & ModuleMap::PrivateHeader);
322 // Prefer a non-textual header over a textual header.
323 if ((New.getRole() & ModuleMap::TextualHeader) !=
324 (Old.getRole() & ModuleMap::TextualHeader))
325 return !(New.getRole() & ModuleMap::TextualHeader);
327 // Don't have a reason to choose between these. Just keep the first one.
331 ModuleMap::KnownHeader ModuleMap::findModuleForHeader(const FileEntry *File,
333 auto MakeResult = [&](ModuleMap::KnownHeader R) -> ModuleMap::KnownHeader {
334 if (!AllowTextual && R.getRole() & ModuleMap::TextualHeader)
335 return ModuleMap::KnownHeader();
339 HeadersMap::iterator Known = findKnownHeader(File);
340 if (Known != Headers.end()) {
341 ModuleMap::KnownHeader Result;
342 // Iterate over all modules that 'File' is part of to find the best fit.
343 for (KnownHeader &H : Known->second) {
344 // Prefer a header from the source module over all others.
345 if (H.getModule()->getTopLevelModule() == SourceModule)
346 return MakeResult(H);
347 if (!Result || isBetterKnownHeader(H, Result))
350 return MakeResult(Result);
353 return MakeResult(findOrCreateModuleForHeaderInUmbrellaDir(File));
356 ModuleMap::KnownHeader
357 ModuleMap::findOrCreateModuleForHeaderInUmbrellaDir(const FileEntry *File) {
358 assert(!Headers.count(File) && "already have a module for this header");
360 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
361 KnownHeader H = findHeaderInUmbrellaDirs(File, SkippedDirs);
363 Module *Result = H.getModule();
365 // Search up the module stack until we find a module with an umbrella
367 Module *UmbrellaModule = Result;
368 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
369 UmbrellaModule = UmbrellaModule->Parent;
371 if (UmbrellaModule->InferSubmodules) {
372 const FileEntry *UmbrellaModuleMap =
373 getModuleMapFileForUniquing(UmbrellaModule);
375 // Infer submodules for each of the directories we found between
376 // the directory of the umbrella header and the directory where
377 // the actual header is located.
378 bool Explicit = UmbrellaModule->InferExplicitSubmodules;
380 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
381 // Find or create the module that corresponds to this directory name.
382 SmallString<32> NameBuf;
383 StringRef Name = sanitizeFilenameAsIdentifier(
384 llvm::sys::path::stem(SkippedDirs[I-1]->getName()), NameBuf);
385 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
387 InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
388 Result->IsInferred = true;
390 // Associate the module and the directory.
391 UmbrellaDirs[SkippedDirs[I-1]] = Result;
393 // If inferred submodules export everything they import, add a
394 // wildcard to the set of exports.
395 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
396 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
399 // Infer a submodule with the same name as this header file.
400 SmallString<32> NameBuf;
401 StringRef Name = sanitizeFilenameAsIdentifier(
402 llvm::sys::path::stem(File->getName()), NameBuf);
403 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
405 InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
406 Result->IsInferred = true;
407 Result->addTopHeader(File);
409 // If inferred submodules export everything they import, add a
410 // wildcard to the set of exports.
411 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
412 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
414 // Record each of the directories we stepped through as being part of
415 // the module we found, since the umbrella header covers them all.
416 for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
417 UmbrellaDirs[SkippedDirs[I]] = Result;
420 KnownHeader Header(Result, NormalHeader);
421 Headers[File].push_back(Header);
425 return KnownHeader();
428 ArrayRef<ModuleMap::KnownHeader>
429 ModuleMap::findAllModulesForHeader(const FileEntry *File) const {
430 auto It = Headers.find(File);
431 if (It == Headers.end())
436 bool ModuleMap::isHeaderInUnavailableModule(const FileEntry *Header) const {
437 return isHeaderUnavailableInModule(Header, nullptr);
441 ModuleMap::isHeaderUnavailableInModule(const FileEntry *Header,
442 const Module *RequestingModule) const {
443 HeadersMap::const_iterator Known = Headers.find(Header);
444 if (Known != Headers.end()) {
445 for (SmallVectorImpl<KnownHeader>::const_iterator
446 I = Known->second.begin(),
447 E = Known->second.end();
450 if (I->isAvailable() &&
451 (!RequestingModule ||
452 I->getModule()->isSubModuleOf(RequestingModule))) {
453 // When no requesting module is available, the caller is looking if a
454 // header is part a module by only looking into the module map. This is
455 // done by warn_uncovered_module_header checks; don't consider textual
456 // headers part of it in this mode, otherwise we get misleading warnings
457 // that a umbrella header is not including a textual header.
458 if (!RequestingModule && I->getRole() == ModuleMap::TextualHeader)
466 const DirectoryEntry *Dir = Header->getDir();
467 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
468 StringRef DirName = Dir->getName();
470 auto IsUnavailable = [&](const Module *M) {
471 return !M->isAvailable() && (!RequestingModule ||
472 M->isSubModuleOf(RequestingModule));
475 // Keep walking up the directory hierarchy, looking for a directory with
476 // an umbrella header.
478 llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir
479 = UmbrellaDirs.find(Dir);
480 if (KnownDir != UmbrellaDirs.end()) {
481 Module *Found = KnownDir->second;
482 if (IsUnavailable(Found))
485 // Search up the module stack until we find a module with an umbrella
487 Module *UmbrellaModule = Found;
488 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
489 UmbrellaModule = UmbrellaModule->Parent;
491 if (UmbrellaModule->InferSubmodules) {
492 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
493 // Find or create the module that corresponds to this directory name.
494 SmallString<32> NameBuf;
495 StringRef Name = sanitizeFilenameAsIdentifier(
496 llvm::sys::path::stem(SkippedDirs[I-1]->getName()),
498 Found = lookupModuleQualified(Name, Found);
501 if (IsUnavailable(Found))
505 // Infer a submodule with the same name as this header file.
506 SmallString<32> NameBuf;
507 StringRef Name = sanitizeFilenameAsIdentifier(
508 llvm::sys::path::stem(Header->getName()),
510 Found = lookupModuleQualified(Name, Found);
515 return IsUnavailable(Found);
518 SkippedDirs.push_back(Dir);
520 // Retrieve our parent path.
521 DirName = llvm::sys::path::parent_path(DirName);
525 // Resolve the parent path to a directory entry.
526 Dir = SourceMgr.getFileManager().getDirectory(DirName);
532 Module *ModuleMap::findModule(StringRef Name) const {
533 llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name);
534 if (Known != Modules.end())
535 return Known->getValue();
540 Module *ModuleMap::lookupModuleUnqualified(StringRef Name,
541 Module *Context) const {
542 for(; Context; Context = Context->Parent) {
543 if (Module *Sub = lookupModuleQualified(Name, Context))
547 return findModule(Name);
550 Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{
552 return findModule(Name);
554 return Context->findSubmodule(Name);
557 std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
561 // Try to find an existing module with this name.
562 if (Module *Sub = lookupModuleQualified(Name, Parent))
563 return std::make_pair(Sub, false);
565 // Create a new module with this name.
566 Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
567 IsExplicit, NumCreatedModules++);
569 if (LangOpts.CurrentModule == Name)
570 SourceModule = Result;
571 Modules[Name] = Result;
573 return std::make_pair(Result, true);
576 Module *ModuleMap::createModuleForInterfaceUnit(SourceLocation Loc,
578 assert(LangOpts.CurrentModule == Name && "module name mismatch");
579 assert(!Modules[Name] && "redefining existing module");
582 new Module(Name, Loc, nullptr, /*IsFramework*/ false,
583 /*IsExplicit*/ false, NumCreatedModules++);
584 Result->Kind = Module::ModuleInterfaceUnit;
585 Modules[Name] = SourceModule = Result;
587 // Mark the main source file as being within the newly-created module so that
588 // declarations and macros are properly visibility-restricted to it.
589 auto *MainFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
590 assert(MainFile && "no input file for module interface");
591 Headers[MainFile].push_back(KnownHeader(Result, PrivateHeader));
596 /// \brief For a framework module, infer the framework against which we
598 static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir,
599 FileManager &FileMgr) {
600 assert(Mod->IsFramework && "Can only infer linking for framework modules");
601 assert(!Mod->isSubFramework() &&
602 "Can only infer linking for top-level frameworks");
604 SmallString<128> LibName;
605 LibName += FrameworkDir->getName();
606 llvm::sys::path::append(LibName, Mod->Name);
608 // The library name of a framework has more than one possible extension since
609 // the introduction of the text-based dynamic library format. We need to check
610 // for both before we give up.
611 for (const char *extension : {"", ".tbd"}) {
612 llvm::sys::path::replace_extension(LibName, extension);
613 if (FileMgr.getFile(LibName)) {
614 Mod->LinkLibraries.push_back(Module::LinkLibrary(Mod->Name,
615 /*IsFramework=*/true));
621 Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
622 bool IsSystem, Module *Parent) {
624 Attrs.IsSystem = IsSystem;
625 return inferFrameworkModule(FrameworkDir, Attrs, Parent);
628 Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
629 Attributes Attrs, Module *Parent) {
630 // Note: as an egregious but useful hack we use the real path here, because
631 // we might be looking at an embedded framework that symlinks out to a
632 // top-level framework, and we need to infer as if we were naming the
633 // top-level framework.
634 StringRef FrameworkDirName =
635 SourceMgr.getFileManager().getCanonicalName(FrameworkDir);
637 // In case this is a case-insensitive filesystem, use the canonical
638 // directory name as the ModuleName, since modules are case-sensitive.
639 // FIXME: we should be able to give a fix-it hint for the correct spelling.
640 SmallString<32> ModuleNameStorage;
641 StringRef ModuleName = sanitizeFilenameAsIdentifier(
642 llvm::sys::path::stem(FrameworkDirName), ModuleNameStorage);
644 // Check whether we've already found this module.
645 if (Module *Mod = lookupModuleQualified(ModuleName, Parent))
648 FileManager &FileMgr = SourceMgr.getFileManager();
650 // If the framework has a parent path from which we're allowed to infer
651 // a framework module, do so.
652 const FileEntry *ModuleMapFile = nullptr;
654 // Determine whether we're allowed to infer a module map.
655 bool canInfer = false;
656 if (llvm::sys::path::has_parent_path(FrameworkDirName)) {
657 // Figure out the parent path.
658 StringRef Parent = llvm::sys::path::parent_path(FrameworkDirName);
659 if (const DirectoryEntry *ParentDir = FileMgr.getDirectory(Parent)) {
660 // Check whether we have already looked into the parent directory
662 llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
663 inferred = InferredDirectories.find(ParentDir);
664 if (inferred == InferredDirectories.end()) {
665 // We haven't looked here before. Load a module map, if there is
667 bool IsFrameworkDir = Parent.endswith(".framework");
668 if (const FileEntry *ModMapFile =
669 HeaderInfo.lookupModuleMapFile(ParentDir, IsFrameworkDir)) {
670 parseModuleMapFile(ModMapFile, Attrs.IsSystem, ParentDir);
671 inferred = InferredDirectories.find(ParentDir);
674 if (inferred == InferredDirectories.end())
675 inferred = InferredDirectories.insert(
676 std::make_pair(ParentDir, InferredDirectory())).first;
679 if (inferred->second.InferModules) {
680 // We're allowed to infer for this directory, but make sure it's okay
681 // to infer this particular module.
682 StringRef Name = llvm::sys::path::stem(FrameworkDirName);
683 canInfer = std::find(inferred->second.ExcludedModules.begin(),
684 inferred->second.ExcludedModules.end(),
685 Name) == inferred->second.ExcludedModules.end();
687 Attrs.IsSystem |= inferred->second.Attrs.IsSystem;
688 Attrs.IsExternC |= inferred->second.Attrs.IsExternC;
689 Attrs.IsExhaustive |= inferred->second.Attrs.IsExhaustive;
690 Attrs.NoUndeclaredIncludes |=
691 inferred->second.Attrs.NoUndeclaredIncludes;
692 ModuleMapFile = inferred->second.ModuleMapFile;
697 // If we're not allowed to infer a framework module, don't.
701 ModuleMapFile = getModuleMapFileForUniquing(Parent);
704 // Look for an umbrella header.
705 SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
706 llvm::sys::path::append(UmbrellaName, "Headers", ModuleName + ".h");
707 const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName);
709 // FIXME: If there's no umbrella header, we could probably scan the
710 // framework to load *everything*. But, it's not clear that this is a good
715 Module *Result = new Module(ModuleName, SourceLocation(), Parent,
716 /*IsFramework=*/true, /*IsExplicit=*/false,
717 NumCreatedModules++);
718 InferredModuleAllowedBy[Result] = ModuleMapFile;
719 Result->IsInferred = true;
721 if (LangOpts.CurrentModule == ModuleName)
722 SourceModule = Result;
723 Modules[ModuleName] = Result;
726 Result->IsSystem |= Attrs.IsSystem;
727 Result->IsExternC |= Attrs.IsExternC;
728 Result->ConfigMacrosExhaustive |= Attrs.IsExhaustive;
729 Result->NoUndeclaredIncludes |= Attrs.NoUndeclaredIncludes;
730 Result->Directory = FrameworkDir;
732 // umbrella header "umbrella-header-name"
734 // The "Headers/" component of the name is implied because this is
735 // a framework module.
736 setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h");
739 Result->Exports.push_back(Module::ExportDecl(nullptr, true));
741 // module * { export * }
742 Result->InferSubmodules = true;
743 Result->InferExportWildcard = true;
745 // Look for subframeworks.
747 SmallString<128> SubframeworksDirName
748 = StringRef(FrameworkDir->getName());
749 llvm::sys::path::append(SubframeworksDirName, "Frameworks");
750 llvm::sys::path::native(SubframeworksDirName);
751 vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
752 for (vfs::directory_iterator Dir = FS.dir_begin(SubframeworksDirName, EC),
754 Dir != DirEnd && !EC; Dir.increment(EC)) {
755 if (!StringRef(Dir->getName()).endswith(".framework"))
758 if (const DirectoryEntry *SubframeworkDir =
759 FileMgr.getDirectory(Dir->getName())) {
760 // Note: as an egregious but useful hack, we use the real path here and
761 // check whether it is actually a subdirectory of the parent directory.
762 // This will not be the case if the 'subframework' is actually a symlink
763 // out to a top-level framework.
764 StringRef SubframeworkDirName = FileMgr.getCanonicalName(SubframeworkDir);
765 bool FoundParent = false;
767 // Get the parent directory name.
769 = llvm::sys::path::parent_path(SubframeworkDirName);
770 if (SubframeworkDirName.empty())
773 if (FileMgr.getDirectory(SubframeworkDirName) == FrameworkDir) {
782 // FIXME: Do we want to warn about subframeworks without umbrella headers?
783 inferFrameworkModule(SubframeworkDir, Attrs, Result);
787 // If the module is a top-level framework, automatically link against the
789 if (!Result->isSubFramework()) {
790 inferFrameworkLink(Result, FrameworkDir, FileMgr);
796 void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader,
797 Twine NameAsWritten) {
798 Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
799 Mod->Umbrella = UmbrellaHeader;
800 Mod->UmbrellaAsWritten = NameAsWritten.str();
801 UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
803 // Notify callbacks that we just added a new header.
804 for (const auto &Cb : Callbacks)
805 Cb->moduleMapAddUmbrellaHeader(&SourceMgr.getFileManager(), UmbrellaHeader);
808 void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir,
809 Twine NameAsWritten) {
810 Mod->Umbrella = UmbrellaDir;
811 Mod->UmbrellaAsWritten = NameAsWritten.str();
812 UmbrellaDirs[UmbrellaDir] = Mod;
815 static Module::HeaderKind headerRoleToKind(ModuleMap::ModuleHeaderRole Role) {
817 default: llvm_unreachable("unknown header role");
818 case ModuleMap::NormalHeader:
819 return Module::HK_Normal;
820 case ModuleMap::PrivateHeader:
821 return Module::HK_Private;
822 case ModuleMap::TextualHeader:
823 return Module::HK_Textual;
824 case ModuleMap::PrivateHeader | ModuleMap::TextualHeader:
825 return Module::HK_PrivateTextual;
829 void ModuleMap::addHeader(Module *Mod, Module::Header Header,
830 ModuleHeaderRole Role, bool Imported) {
831 KnownHeader KH(Mod, Role);
833 // Only add each header to the headers list once.
834 // FIXME: Should we diagnose if a header is listed twice in the
835 // same module definition?
836 auto &HeaderList = Headers[Header.Entry];
837 for (auto H : HeaderList)
841 HeaderList.push_back(KH);
842 Mod->Headers[headerRoleToKind(Role)].push_back(Header);
844 bool isCompilingModuleHeader =
845 LangOpts.isCompilingModule() && Mod->getTopLevelModule() == SourceModule;
846 if (!Imported || isCompilingModuleHeader) {
847 // When we import HeaderFileInfo, the external source is expected to
848 // set the isModuleHeader flag itself.
849 HeaderInfo.MarkFileModuleHeader(Header.Entry, Role,
850 isCompilingModuleHeader);
853 // Notify callbacks that we just added a new header.
854 for (const auto &Cb : Callbacks)
855 Cb->moduleMapAddHeader(Header.Entry->getName());
858 void ModuleMap::excludeHeader(Module *Mod, Module::Header Header) {
859 // Add this as a known header so we won't implicitly add it to any
860 // umbrella directory module.
861 // FIXME: Should we only exclude it from umbrella modules within the
863 (void) Headers[Header.Entry];
865 Mod->Headers[Module::HK_Excluded].push_back(std::move(Header));
869 ModuleMap::getContainingModuleMapFile(const Module *Module) const {
870 if (Module->DefinitionLoc.isInvalid())
873 return SourceMgr.getFileEntryForID(
874 SourceMgr.getFileID(Module->DefinitionLoc));
877 const FileEntry *ModuleMap::getModuleMapFileForUniquing(const Module *M) const {
879 assert(InferredModuleAllowedBy.count(M) && "missing inferred module map");
880 return InferredModuleAllowedBy.find(M)->second;
882 return getContainingModuleMapFile(M);
885 void ModuleMap::setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap) {
886 assert(M->IsInferred && "module not inferred");
887 InferredModuleAllowedBy[M] = ModMap;
890 LLVM_DUMP_METHOD void ModuleMap::dump() {
891 llvm::errs() << "Modules:";
892 for (llvm::StringMap<Module *>::iterator M = Modules.begin(),
893 MEnd = Modules.end();
895 M->getValue()->print(llvm::errs(), 2);
897 llvm::errs() << "Headers:";
898 for (HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end();
900 llvm::errs() << " \"" << H->first->getName() << "\" -> ";
901 for (SmallVectorImpl<KnownHeader>::const_iterator I = H->second.begin(),
904 if (I != H->second.begin())
906 llvm::errs() << I->getModule()->getFullModuleName();
908 llvm::errs() << "\n";
912 bool ModuleMap::resolveExports(Module *Mod, bool Complain) {
913 auto Unresolved = std::move(Mod->UnresolvedExports);
914 Mod->UnresolvedExports.clear();
915 for (auto &UE : Unresolved) {
916 Module::ExportDecl Export = resolveExport(Mod, UE, Complain);
917 if (Export.getPointer() || Export.getInt())
918 Mod->Exports.push_back(Export);
920 Mod->UnresolvedExports.push_back(UE);
922 return !Mod->UnresolvedExports.empty();
925 bool ModuleMap::resolveUses(Module *Mod, bool Complain) {
926 auto Unresolved = std::move(Mod->UnresolvedDirectUses);
927 Mod->UnresolvedDirectUses.clear();
928 for (auto &UDU : Unresolved) {
929 Module *DirectUse = resolveModuleId(UDU, Mod, Complain);
931 Mod->DirectUses.push_back(DirectUse);
933 Mod->UnresolvedDirectUses.push_back(UDU);
935 return !Mod->UnresolvedDirectUses.empty();
938 bool ModuleMap::resolveConflicts(Module *Mod, bool Complain) {
939 auto Unresolved = std::move(Mod->UnresolvedConflicts);
940 Mod->UnresolvedConflicts.clear();
941 for (auto &UC : Unresolved) {
942 if (Module *OtherMod = resolveModuleId(UC.Id, Mod, Complain)) {
943 Module::Conflict Conflict;
944 Conflict.Other = OtherMod;
945 Conflict.Message = UC.Message;
946 Mod->Conflicts.push_back(Conflict);
948 Mod->UnresolvedConflicts.push_back(UC);
950 return !Mod->UnresolvedConflicts.empty();
953 Module *ModuleMap::inferModuleFromLocation(FullSourceLoc Loc) {
957 if (UmbrellaDirs.empty() && Headers.empty())
960 // Use the expansion location to determine which module we're in.
961 FullSourceLoc ExpansionLoc = Loc.getExpansionLoc();
962 if (!ExpansionLoc.isFileID())
965 const SourceManager &SrcMgr = Loc.getManager();
966 FileID ExpansionFileID = ExpansionLoc.getFileID();
968 while (const FileEntry *ExpansionFile
969 = SrcMgr.getFileEntryForID(ExpansionFileID)) {
970 // Find the module that owns this header (if any).
971 if (Module *Mod = findModuleForHeader(ExpansionFile).getModule())
974 // No module owns this header, so look up the inclusion chain to see if
975 // any included header has an associated module.
976 SourceLocation IncludeLoc = SrcMgr.getIncludeLoc(ExpansionFileID);
977 if (IncludeLoc.isInvalid())
980 ExpansionFileID = SrcMgr.getFileID(IncludeLoc);
986 //----------------------------------------------------------------------------//
987 // Module map file parser
988 //----------------------------------------------------------------------------//
991 /// \brief A token in a module map file.
1023 unsigned StringLength;
1024 const char *StringData;
1030 StringData = nullptr;
1033 bool is(TokenKind K) const { return Kind == K; }
1035 SourceLocation getLocation() const {
1036 return SourceLocation::getFromRawEncoding(Location);
1039 StringRef getString() const {
1040 return StringRef(StringData, StringLength);
1044 class ModuleMapParser {
1046 SourceManager &SourceMgr;
1048 /// \brief Default target information, used only for string literal
1050 const TargetInfo *Target;
1052 DiagnosticsEngine &Diags;
1055 /// \brief The current module map file.
1056 const FileEntry *ModuleMapFile;
1058 /// \brief The directory that file names in this module map file should
1059 /// be resolved relative to.
1060 const DirectoryEntry *Directory;
1062 /// \brief The directory containing Clang-supplied headers.
1063 const DirectoryEntry *BuiltinIncludeDir;
1065 /// \brief Whether this module map is in a system header directory.
1068 /// \brief Whether an error occurred.
1071 /// \brief Stores string data for the various string literals referenced
1073 llvm::BumpPtrAllocator StringData;
1075 /// \brief The current token.
1078 /// \brief The active module.
1079 Module *ActiveModule;
1081 /// \brief Whether a module uses the 'requires excluded' hack to mark its
1082 /// contents as 'textual'.
1084 /// On older Darwin SDK versions, 'requires excluded' is used to mark the
1085 /// contents of the Darwin.C.excluded (assert.h) and Tcl.Private modules as
1086 /// non-modular headers. For backwards compatibility, we continue to
1087 /// support this idiom for just these modules, and map the headers to
1088 /// 'textual' to match the original intent.
1089 llvm::SmallPtrSet<Module *, 2> UsesRequiresExcludedHack;
1091 /// \brief Consume the current token and return its location.
1092 SourceLocation consumeToken();
1094 /// \brief Skip tokens until we reach the a token with the given kind
1095 /// (or the end of the file).
1096 void skipUntil(MMToken::TokenKind K);
1098 typedef SmallVector<std::pair<std::string, SourceLocation>, 2> ModuleId;
1099 bool parseModuleId(ModuleId &Id);
1100 void parseModuleDecl();
1101 void parseExternModuleDecl();
1102 void parseRequiresDecl();
1103 void parseHeaderDecl(clang::MMToken::TokenKind,
1104 SourceLocation LeadingLoc);
1105 void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc);
1106 void parseExportDecl();
1107 void parseUseDecl();
1108 void parseLinkDecl();
1109 void parseConfigMacros();
1110 void parseConflict();
1111 void parseInferredModuleDecl(bool Framework, bool Explicit);
1113 typedef ModuleMap::Attributes Attributes;
1114 bool parseOptionalAttributes(Attributes &Attrs);
1117 explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
1118 const TargetInfo *Target,
1119 DiagnosticsEngine &Diags,
1121 const FileEntry *ModuleMapFile,
1122 const DirectoryEntry *Directory,
1123 const DirectoryEntry *BuiltinIncludeDir,
1125 : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
1126 ModuleMapFile(ModuleMapFile), Directory(Directory),
1127 BuiltinIncludeDir(BuiltinIncludeDir), IsSystem(IsSystem),
1128 HadError(false), ActiveModule(nullptr)
1134 bool parseModuleMapFile();
1136 bool terminatedByDirective() { return false; }
1137 SourceLocation getLocation() { return Tok.getLocation(); }
1141 SourceLocation ModuleMapParser::consumeToken() {
1142 SourceLocation Result = Tok.getLocation();
1147 L.LexFromRawLexer(LToken);
1148 Tok.Location = LToken.getLocation().getRawEncoding();
1149 switch (LToken.getKind()) {
1150 case tok::raw_identifier: {
1151 StringRef RI = LToken.getRawIdentifier();
1152 Tok.StringData = RI.data();
1153 Tok.StringLength = RI.size();
1154 Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(RI)
1155 .Case("config_macros", MMToken::ConfigMacros)
1156 .Case("conflict", MMToken::Conflict)
1157 .Case("exclude", MMToken::ExcludeKeyword)
1158 .Case("explicit", MMToken::ExplicitKeyword)
1159 .Case("export", MMToken::ExportKeyword)
1160 .Case("extern", MMToken::ExternKeyword)
1161 .Case("framework", MMToken::FrameworkKeyword)
1162 .Case("header", MMToken::HeaderKeyword)
1163 .Case("link", MMToken::LinkKeyword)
1164 .Case("module", MMToken::ModuleKeyword)
1165 .Case("private", MMToken::PrivateKeyword)
1166 .Case("requires", MMToken::RequiresKeyword)
1167 .Case("textual", MMToken::TextualKeyword)
1168 .Case("umbrella", MMToken::UmbrellaKeyword)
1169 .Case("use", MMToken::UseKeyword)
1170 .Default(MMToken::Identifier);
1175 Tok.Kind = MMToken::Comma;
1179 Tok.Kind = MMToken::EndOfFile;
1183 Tok.Kind = MMToken::LBrace;
1187 Tok.Kind = MMToken::LSquare;
1191 Tok.Kind = MMToken::Period;
1195 Tok.Kind = MMToken::RBrace;
1199 Tok.Kind = MMToken::RSquare;
1203 Tok.Kind = MMToken::Star;
1207 Tok.Kind = MMToken::Exclaim;
1210 case tok::string_literal: {
1211 if (LToken.hasUDSuffix()) {
1212 Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl);
1217 // Parse the string literal.
1218 LangOptions LangOpts;
1219 StringLiteralParser StringLiteral(LToken, SourceMgr, LangOpts, *Target);
1220 if (StringLiteral.hadError)
1223 // Copy the string literal into our string data allocator.
1224 unsigned Length = StringLiteral.GetStringLength();
1225 char *Saved = StringData.Allocate<char>(Length + 1);
1226 memcpy(Saved, StringLiteral.GetString().data(), Length);
1230 Tok.Kind = MMToken::StringLiteral;
1231 Tok.StringData = Saved;
1232 Tok.StringLength = Length;
1240 // A module map can be terminated prematurely by
1241 // #pragma clang module contents
1242 // When building the module, we'll treat the rest of the file as the
1243 // contents of the module.
1245 auto NextIsIdent = [&](StringRef Str) -> bool {
1246 L.LexFromRawLexer(LToken);
1247 return !LToken.isAtStartOfLine() && LToken.is(tok::raw_identifier) &&
1248 LToken.getRawIdentifier() == Str;
1250 if (NextIsIdent("pragma") && NextIsIdent("clang") &&
1251 NextIsIdent("module") && NextIsIdent("contents")) {
1252 Tok.Kind = MMToken::EndOfFile;
1259 Diags.Report(Tok.getLocation(), diag::err_mmap_unknown_token);
1267 void ModuleMapParser::skipUntil(MMToken::TokenKind K) {
1268 unsigned braceDepth = 0;
1269 unsigned squareDepth = 0;
1272 case MMToken::EndOfFile:
1275 case MMToken::LBrace:
1276 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1282 case MMToken::LSquare:
1283 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1289 case MMToken::RBrace:
1296 case MMToken::RSquare:
1297 if (squareDepth > 0)
1304 if (braceDepth == 0 && squareDepth == 0 && Tok.is(K))
1313 /// \brief Parse a module-id.
1317 /// identifier '.' module-id
1319 /// \returns true if an error occurred, false otherwise.
1320 bool ModuleMapParser::parseModuleId(ModuleId &Id) {
1323 if (Tok.is(MMToken::Identifier) || Tok.is(MMToken::StringLiteral)) {
1324 Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation()));
1327 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name);
1331 if (!Tok.is(MMToken::Period))
1341 /// \brief Enumerates the known attributes.
1342 enum AttributeKind {
1343 /// \brief An unknown attribute.
1345 /// \brief The 'system' attribute.
1347 /// \brief The 'extern_c' attribute.
1349 /// \brief The 'exhaustive' attribute.
1351 /// \brief The 'no_undeclared_includes' attribute.
1352 AT_no_undeclared_includes
1356 /// \brief Parse a module declaration.
1358 /// module-declaration:
1359 /// 'extern' 'module' module-id string-literal
1360 /// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt]
1361 /// { module-member* }
1364 /// requires-declaration
1365 /// header-declaration
1366 /// submodule-declaration
1367 /// export-declaration
1368 /// link-declaration
1370 /// submodule-declaration:
1371 /// module-declaration
1372 /// inferred-submodule-declaration
1373 void ModuleMapParser::parseModuleDecl() {
1374 assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) ||
1375 Tok.is(MMToken::FrameworkKeyword) || Tok.is(MMToken::ExternKeyword));
1376 if (Tok.is(MMToken::ExternKeyword)) {
1377 parseExternModuleDecl();
1381 // Parse 'explicit' or 'framework' keyword, if present.
1382 SourceLocation ExplicitLoc;
1383 bool Explicit = false;
1384 bool Framework = false;
1386 // Parse 'explicit' keyword, if present.
1387 if (Tok.is(MMToken::ExplicitKeyword)) {
1388 ExplicitLoc = consumeToken();
1392 // Parse 'framework' keyword, if present.
1393 if (Tok.is(MMToken::FrameworkKeyword)) {
1398 // Parse 'module' keyword.
1399 if (!Tok.is(MMToken::ModuleKeyword)) {
1400 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1405 consumeToken(); // 'module' keyword
1407 // If we have a wildcard for the module name, this is an inferred submodule.
1409 if (Tok.is(MMToken::Star))
1410 return parseInferredModuleDecl(Framework, Explicit);
1412 // Parse the module name.
1414 if (parseModuleId(Id)) {
1420 if (Id.size() > 1) {
1421 Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id)
1422 << SourceRange(Id.front().second, Id.back().second);
1427 } else if (Id.size() == 1 && Explicit) {
1428 // Top-level modules can't be explicit.
1429 Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level);
1431 ExplicitLoc = SourceLocation();
1435 Module *PreviousActiveModule = ActiveModule;
1436 if (Id.size() > 1) {
1437 // This module map defines a submodule. Go find the module of which it
1439 ActiveModule = nullptr;
1440 const Module *TopLevelModule = nullptr;
1441 for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) {
1442 if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) {
1444 TopLevelModule = Next;
1445 ActiveModule = Next;
1450 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
1452 << ActiveModule->getTopLevelModule()->getFullModuleName();
1454 Diags.Report(Id[I].second, diag::err_mmap_expected_module_name);
1460 if (ModuleMapFile != Map.getContainingModuleMapFile(TopLevelModule)) {
1461 assert(ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) &&
1462 "submodule defined in same file as 'module *' that allowed its "
1463 "top-level module");
1464 Map.addAdditionalModuleMapFile(TopLevelModule, ModuleMapFile);
1468 StringRef ModuleName = Id.back().first;
1469 SourceLocation ModuleNameLoc = Id.back().second;
1471 // Parse the optional attribute list.
1473 if (parseOptionalAttributes(Attrs))
1477 // Parse the opening brace.
1478 if (!Tok.is(MMToken::LBrace)) {
1479 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
1484 SourceLocation LBraceLoc = consumeToken();
1486 // Determine whether this (sub)module has already been defined.
1487 if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
1488 if (Existing->DefinitionLoc.isInvalid() && !ActiveModule) {
1489 // Skip the module definition.
1490 skipUntil(MMToken::RBrace);
1491 if (Tok.is(MMToken::RBrace))
1494 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1495 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1501 Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
1503 Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition);
1505 // Skip the module definition.
1506 skipUntil(MMToken::RBrace);
1507 if (Tok.is(MMToken::RBrace))
1514 // Start defining this module.
1515 ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework,
1517 ActiveModule->DefinitionLoc = ModuleNameLoc;
1518 if (Attrs.IsSystem || IsSystem)
1519 ActiveModule->IsSystem = true;
1520 if (Attrs.IsExternC)
1521 ActiveModule->IsExternC = true;
1522 if (Attrs.NoUndeclaredIncludes ||
1523 (!ActiveModule->Parent && ModuleName == "Darwin"))
1524 ActiveModule->NoUndeclaredIncludes = true;
1525 ActiveModule->Directory = Directory;
1527 if (!ActiveModule->Parent) {
1528 StringRef MapFileName(ModuleMapFile->getName());
1529 if (MapFileName.endswith("module.private.modulemap") ||
1530 MapFileName.endswith("module_private.map")) {
1531 // Adding a top-level module from a private modulemap is likely a
1532 // user error; we check to see if there's another top-level module
1533 // defined in the non-private map in the same dir, and if so emit a
1535 for (auto E = Map.module_begin(); E != Map.module_end(); ++E) {
1536 auto const *M = E->getValue();
1538 M->Directory == ActiveModule->Directory &&
1539 M->Name != ActiveModule->Name) {
1540 Diags.Report(ActiveModule->DefinitionLoc,
1541 diag::warn_mmap_mismatched_top_level_private)
1542 << ActiveModule->Name << M->Name;
1543 // The pattern we're defending against here is typically due to
1544 // a module named FooPrivate which is supposed to be a submodule
1545 // called Foo.Private. Emit a fixit in that case.
1547 Diags.Report(ActiveModule->DefinitionLoc,
1548 diag::note_mmap_rename_top_level_private_as_submodule);
1549 D << ActiveModule->Name << M->Name;
1550 StringRef Bad(ActiveModule->Name);
1551 if (Bad.consume_back("Private")) {
1552 SmallString<128> Fixed = Bad;
1553 Fixed.append(".Private");
1554 D << FixItHint::CreateReplacement(ActiveModule->DefinitionLoc,
1566 case MMToken::EndOfFile:
1567 case MMToken::RBrace:
1571 case MMToken::ConfigMacros:
1572 parseConfigMacros();
1575 case MMToken::Conflict:
1579 case MMToken::ExplicitKeyword:
1580 case MMToken::ExternKeyword:
1581 case MMToken::FrameworkKeyword:
1582 case MMToken::ModuleKeyword:
1586 case MMToken::ExportKeyword:
1590 case MMToken::UseKeyword:
1594 case MMToken::RequiresKeyword:
1595 parseRequiresDecl();
1598 case MMToken::TextualKeyword:
1599 parseHeaderDecl(MMToken::TextualKeyword, consumeToken());
1602 case MMToken::UmbrellaKeyword: {
1603 SourceLocation UmbrellaLoc = consumeToken();
1604 if (Tok.is(MMToken::HeaderKeyword))
1605 parseHeaderDecl(MMToken::UmbrellaKeyword, UmbrellaLoc);
1607 parseUmbrellaDirDecl(UmbrellaLoc);
1611 case MMToken::ExcludeKeyword:
1612 parseHeaderDecl(MMToken::ExcludeKeyword, consumeToken());
1615 case MMToken::PrivateKeyword:
1616 parseHeaderDecl(MMToken::PrivateKeyword, consumeToken());
1619 case MMToken::HeaderKeyword:
1620 parseHeaderDecl(MMToken::HeaderKeyword, consumeToken());
1623 case MMToken::LinkKeyword:
1628 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member);
1634 if (Tok.is(MMToken::RBrace))
1637 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1638 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1642 // If the active module is a top-level framework, and there are no link
1643 // libraries, automatically link against the framework.
1644 if (ActiveModule->IsFramework && !ActiveModule->isSubFramework() &&
1645 ActiveModule->LinkLibraries.empty()) {
1646 inferFrameworkLink(ActiveModule, Directory, SourceMgr.getFileManager());
1649 // If the module meets all requirements but is still unavailable, mark the
1650 // whole tree as unavailable to prevent it from building.
1651 if (!ActiveModule->IsAvailable && !ActiveModule->IsMissingRequirement &&
1652 ActiveModule->Parent) {
1653 ActiveModule->getTopLevelModule()->markUnavailable();
1654 ActiveModule->getTopLevelModule()->MissingHeaders.append(
1655 ActiveModule->MissingHeaders.begin(), ActiveModule->MissingHeaders.end());
1658 // We're done parsing this module. Pop back to the previous module.
1659 ActiveModule = PreviousActiveModule;
1662 /// \brief Parse an extern module declaration.
1664 /// extern module-declaration:
1665 /// 'extern' 'module' module-id string-literal
1666 void ModuleMapParser::parseExternModuleDecl() {
1667 assert(Tok.is(MMToken::ExternKeyword));
1668 SourceLocation ExternLoc = consumeToken(); // 'extern' keyword
1670 // Parse 'module' keyword.
1671 if (!Tok.is(MMToken::ModuleKeyword)) {
1672 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1677 consumeToken(); // 'module' keyword
1679 // Parse the module name.
1681 if (parseModuleId(Id)) {
1686 // Parse the referenced module map file name.
1687 if (!Tok.is(MMToken::StringLiteral)) {
1688 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_mmap_file);
1692 std::string FileName = Tok.getString();
1693 consumeToken(); // filename
1695 StringRef FileNameRef = FileName;
1696 SmallString<128> ModuleMapFileName;
1697 if (llvm::sys::path::is_relative(FileNameRef)) {
1698 ModuleMapFileName += Directory->getName();
1699 llvm::sys::path::append(ModuleMapFileName, FileName);
1700 FileNameRef = ModuleMapFileName;
1702 if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef))
1703 Map.parseModuleMapFile(
1704 File, /*IsSystem=*/false,
1705 Map.HeaderInfo.getHeaderSearchOpts().ModuleMapFileHomeIsCwd
1708 FileID(), nullptr, ExternLoc);
1711 /// Whether to add the requirement \p Feature to the module \p M.
1713 /// This preserves backwards compatibility for two hacks in the Darwin system
1714 /// module map files:
1716 /// 1. The use of 'requires excluded' to make headers non-modular, which
1717 /// should really be mapped to 'textual' now that we have this feature. We
1718 /// drop the 'excluded' requirement, and set \p IsRequiresExcludedHack to
1719 /// true. Later, this bit will be used to map all the headers inside this
1720 /// module to 'textual'.
1722 /// This affects Darwin.C.excluded (for assert.h) and Tcl.Private.
1724 /// 2. Removes a bogus cplusplus requirement from IOKit.avc. This requirement
1725 /// was never correct and causes issues now that we check it, so drop it.
1726 static bool shouldAddRequirement(Module *M, StringRef Feature,
1727 bool &IsRequiresExcludedHack) {
1728 if (Feature == "excluded" &&
1729 (M->fullModuleNameIs({"Darwin", "C", "excluded"}) ||
1730 M->fullModuleNameIs({"Tcl", "Private"}))) {
1731 IsRequiresExcludedHack = true;
1733 } else if (Feature == "cplusplus" && M->fullModuleNameIs({"IOKit", "avc"})) {
1740 /// \brief Parse a requires declaration.
1742 /// requires-declaration:
1743 /// 'requires' feature-list
1746 /// feature ',' feature-list
1750 /// '!'[opt] identifier
1751 void ModuleMapParser::parseRequiresDecl() {
1752 assert(Tok.is(MMToken::RequiresKeyword));
1754 // Parse 'requires' keyword.
1757 // Parse the feature-list.
1759 bool RequiredState = true;
1760 if (Tok.is(MMToken::Exclaim)) {
1761 RequiredState = false;
1765 if (!Tok.is(MMToken::Identifier)) {
1766 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
1771 // Consume the feature name.
1772 std::string Feature = Tok.getString();
1775 bool IsRequiresExcludedHack = false;
1776 bool ShouldAddRequirement =
1777 shouldAddRequirement(ActiveModule, Feature, IsRequiresExcludedHack);
1779 if (IsRequiresExcludedHack)
1780 UsesRequiresExcludedHack.insert(ActiveModule);
1782 if (ShouldAddRequirement) {
1783 // Add this feature.
1784 ActiveModule->addRequirement(Feature, RequiredState, Map.LangOpts,
1788 if (!Tok.is(MMToken::Comma))
1791 // Consume the comma.
1796 /// \brief Append to \p Paths the set of paths needed to get to the
1797 /// subframework in which the given module lives.
1798 static void appendSubframeworkPaths(Module *Mod,
1799 SmallVectorImpl<char> &Path) {
1800 // Collect the framework names from the given module to the top-level module.
1801 SmallVector<StringRef, 2> Paths;
1802 for (; Mod; Mod = Mod->Parent) {
1803 if (Mod->IsFramework)
1804 Paths.push_back(Mod->Name);
1810 // Add Frameworks/Name.framework for each subframework.
1811 for (unsigned I = Paths.size() - 1; I != 0; --I)
1812 llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework");
1815 /// \brief Parse a header declaration.
1817 /// header-declaration:
1818 /// 'textual'[opt] 'header' string-literal
1819 /// 'private' 'textual'[opt] 'header' string-literal
1820 /// 'exclude' 'header' string-literal
1821 /// 'umbrella' 'header' string-literal
1823 /// FIXME: Support 'private textual header'.
1824 void ModuleMapParser::parseHeaderDecl(MMToken::TokenKind LeadingToken,
1825 SourceLocation LeadingLoc) {
1826 // We've already consumed the first token.
1827 ModuleMap::ModuleHeaderRole Role = ModuleMap::NormalHeader;
1828 if (LeadingToken == MMToken::PrivateKeyword) {
1829 Role = ModuleMap::PrivateHeader;
1830 // 'private' may optionally be followed by 'textual'.
1831 if (Tok.is(MMToken::TextualKeyword)) {
1832 LeadingToken = Tok.Kind;
1837 if (LeadingToken == MMToken::TextualKeyword)
1838 Role = ModuleMap::ModuleHeaderRole(Role | ModuleMap::TextualHeader);
1840 if (UsesRequiresExcludedHack.count(ActiveModule)) {
1841 // Mark this header 'textual' (see doc comment for
1842 // Module::UsesRequiresExcludedHack).
1843 Role = ModuleMap::ModuleHeaderRole(Role | ModuleMap::TextualHeader);
1846 if (LeadingToken != MMToken::HeaderKeyword) {
1847 if (!Tok.is(MMToken::HeaderKeyword)) {
1848 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
1849 << (LeadingToken == MMToken::PrivateKeyword ? "private" :
1850 LeadingToken == MMToken::ExcludeKeyword ? "exclude" :
1851 LeadingToken == MMToken::TextualKeyword ? "textual" : "umbrella");
1857 // Parse the header name.
1858 if (!Tok.is(MMToken::StringLiteral)) {
1859 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
1864 Module::UnresolvedHeaderDirective Header;
1865 Header.FileName = Tok.getString();
1866 Header.FileNameLoc = consumeToken();
1868 // Check whether we already have an umbrella.
1869 if (LeadingToken == MMToken::UmbrellaKeyword && ActiveModule->Umbrella) {
1870 Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash)
1871 << ActiveModule->getFullModuleName();
1876 // Look for this file.
1877 const FileEntry *File = nullptr;
1878 const FileEntry *BuiltinFile = nullptr;
1879 SmallString<128> RelativePathName;
1880 if (llvm::sys::path::is_absolute(Header.FileName)) {
1881 RelativePathName = Header.FileName;
1882 File = SourceMgr.getFileManager().getFile(RelativePathName);
1884 // Search for the header file within the search directory.
1885 SmallString<128> FullPathName(Directory->getName());
1886 unsigned FullPathLength = FullPathName.size();
1888 if (ActiveModule->isPartOfFramework()) {
1889 appendSubframeworkPaths(ActiveModule, RelativePathName);
1890 unsigned RelativePathLength = RelativePathName.size();
1892 // Check whether this file is in the public headers.
1893 llvm::sys::path::append(RelativePathName, "Headers", Header.FileName);
1894 llvm::sys::path::append(FullPathName, RelativePathName);
1895 File = SourceMgr.getFileManager().getFile(FullPathName);
1897 // Check whether this file is in the private headers.
1899 // Ideally, private modules in the form 'FrameworkName.Private' should
1900 // be defined as 'module FrameworkName.Private', and not as
1901 // 'framework module FrameworkName.Private', since a 'Private.Framework'
1902 // does not usually exist. However, since both are currently widely used
1903 // for private modules, make sure we find the right path in both cases.
1904 RelativePathName.resize(ActiveModule->IsFramework ? 0
1905 : RelativePathLength);
1906 FullPathName.resize(FullPathLength);
1907 llvm::sys::path::append(RelativePathName, "PrivateHeaders",
1909 llvm::sys::path::append(FullPathName, RelativePathName);
1910 File = SourceMgr.getFileManager().getFile(FullPathName);
1913 // Lookup for normal headers.
1914 llvm::sys::path::append(RelativePathName, Header.FileName);
1915 llvm::sys::path::append(FullPathName, RelativePathName);
1916 File = SourceMgr.getFileManager().getFile(FullPathName);
1918 // If this is a system module with a top-level header, this header
1919 // may have a counterpart (or replacement) in the set of headers
1920 // supplied by Clang. Find that builtin header.
1921 if (ActiveModule->IsSystem && LeadingToken != MMToken::UmbrellaKeyword &&
1922 BuiltinIncludeDir && BuiltinIncludeDir != Directory &&
1923 ModuleMap::isBuiltinHeader(Header.FileName)) {
1924 SmallString<128> BuiltinPathName(BuiltinIncludeDir->getName());
1925 llvm::sys::path::append(BuiltinPathName, Header.FileName);
1926 BuiltinFile = SourceMgr.getFileManager().getFile(BuiltinPathName);
1928 // If Clang supplies this header but the underlying system does not,
1929 // just silently swap in our builtin version. Otherwise, we'll end
1930 // up adding both (later).
1931 if (BuiltinFile && !File) {
1933 RelativePathName = BuiltinPathName;
1934 BuiltinFile = nullptr;
1940 // FIXME: We shouldn't be eagerly stat'ing every file named in a module map.
1941 // Come up with a lazy way to do this.
1943 if (LeadingToken == MMToken::UmbrellaKeyword) {
1944 const DirectoryEntry *UmbrellaDir = File->getDir();
1945 if (Module *UmbrellaModule = Map.UmbrellaDirs[UmbrellaDir]) {
1946 Diags.Report(LeadingLoc, diag::err_mmap_umbrella_clash)
1947 << UmbrellaModule->getFullModuleName();
1950 // Record this umbrella header.
1951 Map.setUmbrellaHeader(ActiveModule, File, RelativePathName.str());
1953 } else if (LeadingToken == MMToken::ExcludeKeyword) {
1954 Module::Header H = {RelativePathName.str(), File};
1955 Map.excludeHeader(ActiveModule, H);
1957 // If there is a builtin counterpart to this file, add it now so it can
1958 // wrap the system header.
1960 // FIXME: Taking the name from the FileEntry is unstable and can give
1961 // different results depending on how we've previously named that file
1963 Module::Header H = { BuiltinFile->getName(), BuiltinFile };
1964 Map.addHeader(ActiveModule, H, Role);
1966 // If we have both a builtin and system version of the file, the
1967 // builtin version may want to inject macros into the system header, so
1968 // force the system header to be treated as a textual header in this
1970 Role = ModuleMap::ModuleHeaderRole(Role | ModuleMap::TextualHeader);
1973 // Record this header.
1974 Module::Header H = { RelativePathName.str(), File };
1975 Map.addHeader(ActiveModule, H, Role);
1977 } else if (LeadingToken != MMToken::ExcludeKeyword) {
1978 // Ignore excluded header files. They're optional anyway.
1980 // If we find a module that has a missing header, we mark this module as
1981 // unavailable and store the header directive for displaying diagnostics.
1982 Header.IsUmbrella = LeadingToken == MMToken::UmbrellaKeyword;
1983 ActiveModule->markUnavailable();
1984 ActiveModule->MissingHeaders.push_back(Header);
1988 static int compareModuleHeaders(const Module::Header *A,
1989 const Module::Header *B) {
1990 return A->NameAsWritten.compare(B->NameAsWritten);
1993 /// \brief Parse an umbrella directory declaration.
1995 /// umbrella-dir-declaration:
1996 /// umbrella string-literal
1997 void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) {
1998 // Parse the directory name.
1999 if (!Tok.is(MMToken::StringLiteral)) {
2000 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2006 std::string DirName = Tok.getString();
2007 SourceLocation DirNameLoc = consumeToken();
2009 // Check whether we already have an umbrella.
2010 if (ActiveModule->Umbrella) {
2011 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash)
2012 << ActiveModule->getFullModuleName();
2017 // Look for this file.
2018 const DirectoryEntry *Dir = nullptr;
2019 if (llvm::sys::path::is_absolute(DirName))
2020 Dir = SourceMgr.getFileManager().getDirectory(DirName);
2022 SmallString<128> PathName;
2023 PathName = Directory->getName();
2024 llvm::sys::path::append(PathName, DirName);
2025 Dir = SourceMgr.getFileManager().getDirectory(PathName);
2029 Diags.Report(DirNameLoc, diag::warn_mmap_umbrella_dir_not_found)
2034 if (UsesRequiresExcludedHack.count(ActiveModule)) {
2035 // Mark this header 'textual' (see doc comment for
2036 // ModuleMapParser::UsesRequiresExcludedHack). Although iterating over the
2037 // directory is relatively expensive, in practice this only applies to the
2038 // uncommonly used Tcl module on Darwin platforms.
2040 SmallVector<Module::Header, 6> Headers;
2041 vfs::FileSystem &FS = *SourceMgr.getFileManager().getVirtualFileSystem();
2042 for (vfs::recursive_directory_iterator I(FS, Dir->getName(), EC), E;
2043 I != E && !EC; I.increment(EC)) {
2044 if (const FileEntry *FE =
2045 SourceMgr.getFileManager().getFile(I->getName())) {
2047 Module::Header Header = {I->getName(), FE};
2048 Headers.push_back(std::move(Header));
2052 // Sort header paths so that the pcm doesn't depend on iteration order.
2053 llvm::array_pod_sort(Headers.begin(), Headers.end(), compareModuleHeaders);
2055 for (auto &Header : Headers)
2056 Map.addHeader(ActiveModule, std::move(Header), ModuleMap::TextualHeader);
2060 if (Module *OwningModule = Map.UmbrellaDirs[Dir]) {
2061 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
2062 << OwningModule->getFullModuleName();
2067 // Record this umbrella directory.
2068 Map.setUmbrellaDir(ActiveModule, Dir, DirName);
2071 /// \brief Parse a module export declaration.
2073 /// export-declaration:
2074 /// 'export' wildcard-module-id
2076 /// wildcard-module-id:
2079 /// identifier '.' wildcard-module-id
2080 void ModuleMapParser::parseExportDecl() {
2081 assert(Tok.is(MMToken::ExportKeyword));
2082 SourceLocation ExportLoc = consumeToken();
2084 // Parse the module-id with an optional wildcard at the end.
2085 ModuleId ParsedModuleId;
2086 bool Wildcard = false;
2088 // FIXME: Support string-literal module names here.
2089 if (Tok.is(MMToken::Identifier)) {
2090 ParsedModuleId.push_back(std::make_pair(Tok.getString(),
2091 Tok.getLocation()));
2094 if (Tok.is(MMToken::Period)) {
2102 if(Tok.is(MMToken::Star)) {
2108 Diags.Report(Tok.getLocation(), diag::err_mmap_module_id);
2113 Module::UnresolvedExportDecl Unresolved = {
2114 ExportLoc, ParsedModuleId, Wildcard
2116 ActiveModule->UnresolvedExports.push_back(Unresolved);
2119 /// \brief Parse a module use declaration.
2121 /// use-declaration:
2122 /// 'use' wildcard-module-id
2123 void ModuleMapParser::parseUseDecl() {
2124 assert(Tok.is(MMToken::UseKeyword));
2125 auto KWLoc = consumeToken();
2126 // Parse the module-id.
2127 ModuleId ParsedModuleId;
2128 parseModuleId(ParsedModuleId);
2130 if (ActiveModule->Parent)
2131 Diags.Report(KWLoc, diag::err_mmap_use_decl_submodule);
2133 ActiveModule->UnresolvedDirectUses.push_back(ParsedModuleId);
2136 /// \brief Parse a link declaration.
2138 /// module-declaration:
2139 /// 'link' 'framework'[opt] string-literal
2140 void ModuleMapParser::parseLinkDecl() {
2141 assert(Tok.is(MMToken::LinkKeyword));
2142 SourceLocation LinkLoc = consumeToken();
2144 // Parse the optional 'framework' keyword.
2145 bool IsFramework = false;
2146 if (Tok.is(MMToken::FrameworkKeyword)) {
2151 // Parse the library name
2152 if (!Tok.is(MMToken::StringLiteral)) {
2153 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_library_name)
2154 << IsFramework << SourceRange(LinkLoc);
2159 std::string LibraryName = Tok.getString();
2161 ActiveModule->LinkLibraries.push_back(Module::LinkLibrary(LibraryName,
2165 /// \brief Parse a configuration macro declaration.
2167 /// module-declaration:
2168 /// 'config_macros' attributes[opt] config-macro-list?
2170 /// config-macro-list:
2171 /// identifier (',' identifier)?
2172 void ModuleMapParser::parseConfigMacros() {
2173 assert(Tok.is(MMToken::ConfigMacros));
2174 SourceLocation ConfigMacrosLoc = consumeToken();
2176 // Only top-level modules can have configuration macros.
2177 if (ActiveModule->Parent) {
2178 Diags.Report(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule);
2181 // Parse the optional attributes.
2183 if (parseOptionalAttributes(Attrs))
2186 if (Attrs.IsExhaustive && !ActiveModule->Parent) {
2187 ActiveModule->ConfigMacrosExhaustive = true;
2190 // If we don't have an identifier, we're done.
2191 // FIXME: Support macros with the same name as a keyword here.
2192 if (!Tok.is(MMToken::Identifier))
2195 // Consume the first identifier.
2196 if (!ActiveModule->Parent) {
2197 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2202 // If there's a comma, consume it.
2203 if (!Tok.is(MMToken::Comma))
2207 // We expect to see a macro name here.
2208 // FIXME: Support macros with the same name as a keyword here.
2209 if (!Tok.is(MMToken::Identifier)) {
2210 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_config_macro);
2214 // Consume the macro name.
2215 if (!ActiveModule->Parent) {
2216 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2222 /// \brief Format a module-id into a string.
2223 static std::string formatModuleId(const ModuleId &Id) {
2226 llvm::raw_string_ostream OS(result);
2228 for (unsigned I = 0, N = Id.size(); I != N; ++I) {
2238 /// \brief Parse a conflict declaration.
2240 /// module-declaration:
2241 /// 'conflict' module-id ',' string-literal
2242 void ModuleMapParser::parseConflict() {
2243 assert(Tok.is(MMToken::Conflict));
2244 SourceLocation ConflictLoc = consumeToken();
2245 Module::UnresolvedConflict Conflict;
2247 // Parse the module-id.
2248 if (parseModuleId(Conflict.Id))
2252 if (!Tok.is(MMToken::Comma)) {
2253 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_comma)
2254 << SourceRange(ConflictLoc);
2259 // Parse the message.
2260 if (!Tok.is(MMToken::StringLiteral)) {
2261 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_message)
2262 << formatModuleId(Conflict.Id);
2265 Conflict.Message = Tok.getString().str();
2268 // Add this unresolved conflict.
2269 ActiveModule->UnresolvedConflicts.push_back(Conflict);
2272 /// \brief Parse an inferred module declaration (wildcard modules).
2274 /// module-declaration:
2275 /// 'explicit'[opt] 'framework'[opt] 'module' * attributes[opt]
2276 /// { inferred-module-member* }
2278 /// inferred-module-member:
2280 /// 'exclude' identifier
2281 void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) {
2282 assert(Tok.is(MMToken::Star));
2283 SourceLocation StarLoc = consumeToken();
2284 bool Failed = false;
2286 // Inferred modules must be submodules.
2287 if (!ActiveModule && !Framework) {
2288 Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule);
2293 // Inferred modules must have umbrella directories.
2294 if (!Failed && ActiveModule->IsAvailable &&
2295 !ActiveModule->getUmbrellaDir()) {
2296 Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella);
2300 // Check for redefinition of an inferred module.
2301 if (!Failed && ActiveModule->InferSubmodules) {
2302 Diags.Report(StarLoc, diag::err_mmap_inferred_redef);
2303 if (ActiveModule->InferredSubmoduleLoc.isValid())
2304 Diags.Report(ActiveModule->InferredSubmoduleLoc,
2305 diag::note_mmap_prev_definition);
2309 // Check for the 'framework' keyword, which is not permitted here.
2311 Diags.Report(StarLoc, diag::err_mmap_inferred_framework_submodule);
2314 } else if (Explicit) {
2315 Diags.Report(StarLoc, diag::err_mmap_explicit_inferred_framework);
2319 // If there were any problems with this inferred submodule, skip its body.
2321 if (Tok.is(MMToken::LBrace)) {
2323 skipUntil(MMToken::RBrace);
2324 if (Tok.is(MMToken::RBrace))
2331 // Parse optional attributes.
2333 if (parseOptionalAttributes(Attrs))
2337 // Note that we have an inferred submodule.
2338 ActiveModule->InferSubmodules = true;
2339 ActiveModule->InferredSubmoduleLoc = StarLoc;
2340 ActiveModule->InferExplicitSubmodules = Explicit;
2342 // We'll be inferring framework modules for this directory.
2343 Map.InferredDirectories[Directory].InferModules = true;
2344 Map.InferredDirectories[Directory].Attrs = Attrs;
2345 Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile;
2346 // FIXME: Handle the 'framework' keyword.
2349 // Parse the opening brace.
2350 if (!Tok.is(MMToken::LBrace)) {
2351 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard);
2355 SourceLocation LBraceLoc = consumeToken();
2357 // Parse the body of the inferred submodule.
2361 case MMToken::EndOfFile:
2362 case MMToken::RBrace:
2366 case MMToken::ExcludeKeyword: {
2368 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2369 << (ActiveModule != nullptr);
2375 // FIXME: Support string-literal module names here.
2376 if (!Tok.is(MMToken::Identifier)) {
2377 Diags.Report(Tok.getLocation(), diag::err_mmap_missing_exclude_name);
2381 Map.InferredDirectories[Directory].ExcludedModules
2382 .push_back(Tok.getString());
2387 case MMToken::ExportKeyword:
2388 if (!ActiveModule) {
2389 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2390 << (ActiveModule != nullptr);
2396 if (Tok.is(MMToken::Star))
2397 ActiveModule->InferExportWildcard = true;
2399 Diags.Report(Tok.getLocation(),
2400 diag::err_mmap_expected_export_wildcard);
2404 case MMToken::ExplicitKeyword:
2405 case MMToken::ModuleKeyword:
2406 case MMToken::HeaderKeyword:
2407 case MMToken::PrivateKeyword:
2408 case MMToken::UmbrellaKeyword:
2410 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2411 << (ActiveModule != nullptr);
2417 if (Tok.is(MMToken::RBrace))
2420 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2421 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2426 /// \brief Parse optional attributes.
2429 /// attribute attributes
2435 /// \param Attrs Will be filled in with the parsed attributes.
2437 /// \returns true if an error occurred, false otherwise.
2438 bool ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) {
2439 bool HadError = false;
2441 while (Tok.is(MMToken::LSquare)) {
2443 SourceLocation LSquareLoc = consumeToken();
2445 // Check whether we have an attribute name here.
2446 if (!Tok.is(MMToken::Identifier)) {
2447 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute);
2448 skipUntil(MMToken::RSquare);
2449 if (Tok.is(MMToken::RSquare))
2454 // Decode the attribute name.
2455 AttributeKind Attribute
2456 = llvm::StringSwitch<AttributeKind>(Tok.getString())
2457 .Case("exhaustive", AT_exhaustive)
2458 .Case("extern_c", AT_extern_c)
2459 .Case("no_undeclared_includes", AT_no_undeclared_includes)
2460 .Case("system", AT_system)
2461 .Default(AT_unknown);
2462 switch (Attribute) {
2464 Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute)
2469 Attrs.IsSystem = true;
2473 Attrs.IsExternC = true;
2477 Attrs.IsExhaustive = true;
2480 case AT_no_undeclared_includes:
2481 Attrs.NoUndeclaredIncludes = true;
2487 if (!Tok.is(MMToken::RSquare)) {
2488 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare);
2489 Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match);
2490 skipUntil(MMToken::RSquare);
2494 if (Tok.is(MMToken::RSquare))
2501 /// \brief Parse a module map file.
2503 /// module-map-file:
2504 /// module-declaration*
2505 bool ModuleMapParser::parseModuleMapFile() {
2508 case MMToken::EndOfFile:
2511 case MMToken::ExplicitKeyword:
2512 case MMToken::ExternKeyword:
2513 case MMToken::ModuleKeyword:
2514 case MMToken::FrameworkKeyword:
2518 case MMToken::Comma:
2519 case MMToken::ConfigMacros:
2520 case MMToken::Conflict:
2521 case MMToken::Exclaim:
2522 case MMToken::ExcludeKeyword:
2523 case MMToken::ExportKeyword:
2524 case MMToken::HeaderKeyword:
2525 case MMToken::Identifier:
2526 case MMToken::LBrace:
2527 case MMToken::LinkKeyword:
2528 case MMToken::LSquare:
2529 case MMToken::Period:
2530 case MMToken::PrivateKeyword:
2531 case MMToken::RBrace:
2532 case MMToken::RSquare:
2533 case MMToken::RequiresKeyword:
2535 case MMToken::StringLiteral:
2536 case MMToken::TextualKeyword:
2537 case MMToken::UmbrellaKeyword:
2538 case MMToken::UseKeyword:
2539 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
2547 bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
2548 const DirectoryEntry *Dir, FileID ID,
2550 SourceLocation ExternModuleLoc) {
2551 assert(Target && "Missing target information");
2552 llvm::DenseMap<const FileEntry *, bool>::iterator Known
2553 = ParsedModuleMap.find(File);
2554 if (Known != ParsedModuleMap.end())
2555 return Known->second;
2557 // If the module map file wasn't already entered, do so now.
2558 if (ID.isInvalid()) {
2559 auto FileCharacter = IsSystem ? SrcMgr::C_System : SrcMgr::C_User;
2560 ID = SourceMgr.createFileID(File, ExternModuleLoc, FileCharacter);
2563 assert(Target && "Missing target information");
2564 const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(ID);
2566 return ParsedModuleMap[File] = true;
2567 assert((!Offset || *Offset <= Buffer->getBufferSize()) &&
2568 "invalid buffer offset");
2570 // Parse this module map file.
2571 Lexer L(SourceMgr.getLocForStartOfFile(ID), MMapLangOpts,
2572 Buffer->getBufferStart(),
2573 Buffer->getBufferStart() + (Offset ? *Offset : 0),
2574 Buffer->getBufferEnd());
2575 SourceLocation Start = L.getSourceLocation();
2576 ModuleMapParser Parser(L, SourceMgr, Target, Diags, *this, File, Dir,
2577 BuiltinIncludeDir, IsSystem);
2578 bool Result = Parser.parseModuleMapFile();
2579 ParsedModuleMap[File] = Result;
2582 auto Loc = SourceMgr.getDecomposedLoc(Parser.getLocation());
2583 assert(Loc.first == ID && "stopped in a different file?");
2584 *Offset = Loc.second;
2587 // Notify callbacks that we parsed it.
2588 for (const auto &Cb : Callbacks)
2589 Cb->moduleMapFileRead(Start, *File, IsSystem);