clang  8.0.0svn
ModuleMap.cpp
Go to the documentation of this file.
1 //===- ModuleMap.cpp - Describe the layout of modules ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ModuleMap implementation, which describes the layout
11 // of a module as it relates to headers.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Lex/ModuleMap.h"
16 #include "clang/Basic/CharInfo.h"
17 #include "clang/Basic/Diagnostic.h"
19 #include "clang/Basic/LLVM.h"
21 #include "clang/Basic/Module.h"
24 #include "clang/Basic/TargetInfo.h"
26 #include "clang/Lex/HeaderSearch.h"
29 #include "clang/Lex/Lexer.h"
31 #include "clang/Lex/Token.h"
32 #include "llvm/ADT/DenseMap.h"
33 #include "llvm/ADT/None.h"
34 #include "llvm/ADT/STLExtras.h"
35 #include "llvm/ADT/SmallPtrSet.h"
36 #include "llvm/ADT/SmallString.h"
37 #include "llvm/ADT/SmallVector.h"
38 #include "llvm/ADT/StringMap.h"
39 #include "llvm/ADT/StringRef.h"
40 #include "llvm/ADT/StringSwitch.h"
41 #include "llvm/Support/Allocator.h"
42 #include "llvm/Support/Compiler.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/MemoryBuffer.h"
45 #include "llvm/Support/Path.h"
46 #include "llvm/Support/raw_ostream.h"
47 #include <algorithm>
48 #include <cassert>
49 #include <cstdint>
50 #include <cstring>
51 #include <string>
52 #include <system_error>
53 #include <utility>
54 
55 using namespace clang;
56 
58  auto PendingLinkAs = PendingLinkAsModule.find(Mod->Name);
59  if (PendingLinkAs != PendingLinkAsModule.end()) {
60  for (auto &Name : PendingLinkAs->second) {
61  auto *M = findModule(Name.getKey());
62  if (M)
63  M->UseExportAsModuleLinkName = true;
64  }
65  }
66 }
67 
69  if (findModule(Mod->ExportAsModule))
70  Mod->UseExportAsModuleLinkName = true;
71  else
72  PendingLinkAsModule[Mod->ExportAsModule].insert(Mod->Name);
73 }
74 
76  switch ((int)Role) {
77  default: llvm_unreachable("unknown header role");
78  case NormalHeader:
79  return Module::HK_Normal;
80  case PrivateHeader:
81  return Module::HK_Private;
82  case TextualHeader:
83  return Module::HK_Textual;
86  }
87 }
88 
91  switch ((int)Kind) {
92  case Module::HK_Normal:
93  return NormalHeader;
94  case Module::HK_Private:
95  return PrivateHeader;
96  case Module::HK_Textual:
97  return TextualHeader;
100  case Module::HK_Excluded:
101  llvm_unreachable("unexpected header kind");
102  }
103  llvm_unreachable("unknown header kind");
104 }
105 
107 ModuleMap::resolveExport(Module *Mod,
108  const Module::UnresolvedExportDecl &Unresolved,
109  bool Complain) const {
110  // We may have just a wildcard.
111  if (Unresolved.Id.empty()) {
112  assert(Unresolved.Wildcard && "Invalid unresolved export");
113  return Module::ExportDecl(nullptr, true);
114  }
115 
116  // Resolve the module-id.
117  Module *Context = resolveModuleId(Unresolved.Id, Mod, Complain);
118  if (!Context)
119  return {};
120 
121  return Module::ExportDecl(Context, Unresolved.Wildcard);
122 }
123 
124 Module *ModuleMap::resolveModuleId(const ModuleId &Id, Module *Mod,
125  bool Complain) const {
126  // Find the starting module.
127  Module *Context = lookupModuleUnqualified(Id[0].first, Mod);
128  if (!Context) {
129  if (Complain)
130  Diags.Report(Id[0].second, diag::err_mmap_missing_module_unqualified)
131  << Id[0].first << Mod->getFullModuleName();
132 
133  return nullptr;
134  }
135 
136  // Dig into the module path.
137  for (unsigned I = 1, N = Id.size(); I != N; ++I) {
138  Module *Sub = lookupModuleQualified(Id[I].first, Context);
139  if (!Sub) {
140  if (Complain)
141  Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
142  << Id[I].first << Context->getFullModuleName()
143  << SourceRange(Id[0].second, Id[I-1].second);
144 
145  return nullptr;
146  }
147 
148  Context = Sub;
149  }
150 
151  return Context;
152 }
153 
154 /// Append to \p Paths the set of paths needed to get to the
155 /// subframework in which the given module lives.
157  SmallVectorImpl<char> &Path) {
158  // Collect the framework names from the given module to the top-level module.
160  for (; Mod; Mod = Mod->Parent) {
161  if (Mod->IsFramework)
162  Paths.push_back(Mod->Name);
163  }
164 
165  if (Paths.empty())
166  return;
167 
168  // Add Frameworks/Name.framework for each subframework.
169  for (unsigned I = Paths.size() - 1; I != 0; --I)
170  llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework");
171 }
172 
173 const FileEntry *ModuleMap::findHeader(
174  Module *M, const Module::UnresolvedHeaderDirective &Header,
175  SmallVectorImpl<char> &RelativePathName, bool &NeedsFramework) {
176  // Search for the header file within the module's home directory.
177  auto *Directory = M->Directory;
178  SmallString<128> FullPathName(Directory->getName());
179 
180  auto GetFile = [&](StringRef Filename) -> const FileEntry * {
181  auto *File = SourceMgr.getFileManager().getFile(Filename);
182  if (!File ||
183  (Header.Size && File->getSize() != *Header.Size) ||
184  (Header.ModTime && File->getModificationTime() != *Header.ModTime))
185  return nullptr;
186  return File;
187  };
188 
189  auto GetFrameworkFile = [&]() -> const FileEntry * {
190  unsigned FullPathLength = FullPathName.size();
191  appendSubframeworkPaths(M, RelativePathName);
192  unsigned RelativePathLength = RelativePathName.size();
193 
194  // Check whether this file is in the public headers.
195  llvm::sys::path::append(RelativePathName, "Headers", Header.FileName);
196  llvm::sys::path::append(FullPathName, RelativePathName);
197  if (auto *File = GetFile(FullPathName))
198  return File;
199 
200  // Check whether this file is in the private headers.
201  // Ideally, private modules in the form 'FrameworkName.Private' should
202  // be defined as 'module FrameworkName.Private', and not as
203  // 'framework module FrameworkName.Private', since a 'Private.Framework'
204  // does not usually exist. However, since both are currently widely used
205  // for private modules, make sure we find the right path in both cases.
206  if (M->IsFramework && M->Name == "Private")
207  RelativePathName.clear();
208  else
209  RelativePathName.resize(RelativePathLength);
210  FullPathName.resize(FullPathLength);
211  llvm::sys::path::append(RelativePathName, "PrivateHeaders",
212  Header.FileName);
213  llvm::sys::path::append(FullPathName, RelativePathName);
214  return GetFile(FullPathName);
215  };
216 
217  if (llvm::sys::path::is_absolute(Header.FileName)) {
218  RelativePathName.clear();
219  RelativePathName.append(Header.FileName.begin(), Header.FileName.end());
220  return GetFile(Header.FileName);
221  }
222 
223  if (M->isPartOfFramework())
224  return GetFrameworkFile();
225 
226  // Lookup for normal headers.
227  llvm::sys::path::append(RelativePathName, Header.FileName);
228  llvm::sys::path::append(FullPathName, RelativePathName);
229  auto *NormalHdrFile = GetFile(FullPathName);
230 
231  if (M && !NormalHdrFile && Directory->getName().endswith(".framework")) {
232  // The lack of 'framework' keyword in a module declaration it's a simple
233  // mistake we can diagnose when the header exists within the proper
234  // framework style path.
235  FullPathName.assign(Directory->getName());
236  RelativePathName.clear();
237  if (GetFrameworkFile()) {
238  Diags.Report(Header.FileNameLoc,
239  diag::warn_mmap_incomplete_framework_module_declaration)
240  << Header.FileName << M->getFullModuleName();
241  NeedsFramework = true;
242  }
243  return nullptr;
244  }
245 
246  return NormalHdrFile;
247 }
248 
249 void ModuleMap::resolveHeader(Module *Mod,
250  const Module::UnresolvedHeaderDirective &Header,
251  bool &NeedsFramework) {
252  SmallString<128> RelativePathName;
253  if (const FileEntry *File =
254  findHeader(Mod, Header, RelativePathName, NeedsFramework)) {
255  if (Header.IsUmbrella) {
256  const DirectoryEntry *UmbrellaDir = File->getDir();
257  if (Module *UmbrellaMod = UmbrellaDirs[UmbrellaDir])
258  Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash)
259  << UmbrellaMod->getFullModuleName();
260  else
261  // Record this umbrella header.
262  setUmbrellaHeader(Mod, File, RelativePathName.str());
263  } else {
264  Module::Header H = {RelativePathName.str(), File};
265  if (Header.Kind == Module::HK_Excluded)
266  excludeHeader(Mod, H);
267  else
268  addHeader(Mod, H, headerKindToRole(Header.Kind));
269  }
270  } else if (Header.HasBuiltinHeader && !Header.Size && !Header.ModTime) {
271  // There's a builtin header but no corresponding on-disk header. Assume
272  // this was supposed to modularize the builtin header alone.
273  } else if (Header.Kind == Module::HK_Excluded) {
274  // Ignore missing excluded header files. They're optional anyway.
275  } else {
276  // If we find a module that has a missing header, we mark this module as
277  // unavailable and store the header directive for displaying diagnostics.
278  Mod->MissingHeaders.push_back(Header);
279  // A missing header with stat information doesn't make the module
280  // unavailable; this keeps our behavior consistent as headers are lazily
281  // resolved. (Such a module still can't be built though, except from
282  // preprocessed source.)
283  if (!Header.Size && !Header.ModTime)
284  Mod->markUnavailable();
285  }
286 }
287 
288 bool ModuleMap::resolveAsBuiltinHeader(
289  Module *Mod, const Module::UnresolvedHeaderDirective &Header) {
290  if (Header.Kind == Module::HK_Excluded ||
291  llvm::sys::path::is_absolute(Header.FileName) ||
292  Mod->isPartOfFramework() || !Mod->IsSystem || Header.IsUmbrella ||
293  !BuiltinIncludeDir || BuiltinIncludeDir == Mod->Directory ||
294  !isBuiltinHeader(Header.FileName))
295  return false;
296 
297  // This is a system module with a top-level header. This header
298  // may have a counterpart (or replacement) in the set of headers
299  // supplied by Clang. Find that builtin header.
300  SmallString<128> Path;
301  llvm::sys::path::append(Path, BuiltinIncludeDir->getName(), Header.FileName);
302  auto *File = SourceMgr.getFileManager().getFile(Path);
303  if (!File)
304  return false;
305 
306  auto Role = headerKindToRole(Header.Kind);
307  Module::Header H = {Path.str(), File};
308  addHeader(Mod, H, Role);
309  return true;
310 }
311 
313  const LangOptions &LangOpts, const TargetInfo *Target,
314  HeaderSearch &HeaderInfo)
315  : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target),
316  HeaderInfo(HeaderInfo) {
317  MMapLangOpts.LineComment = true;
318 }
319 
321  for (auto &M : Modules)
322  delete M.getValue();
323  for (auto *M : ShadowModules)
324  delete M;
325 }
326 
327 void ModuleMap::setTarget(const TargetInfo &Target) {
328  assert((!this->Target || this->Target == &Target) &&
329  "Improper target override");
330  this->Target = &Target;
331 }
332 
333 /// "Sanitize" a filename so that it can be used as an identifier.
334 static StringRef sanitizeFilenameAsIdentifier(StringRef Name,
335  SmallVectorImpl<char> &Buffer) {
336  if (Name.empty())
337  return Name;
338 
339  if (!isValidIdentifier(Name)) {
340  // If we don't already have something with the form of an identifier,
341  // create a buffer with the sanitized name.
342  Buffer.clear();
343  if (isDigit(Name[0]))
344  Buffer.push_back('_');
345  Buffer.reserve(Buffer.size() + Name.size());
346  for (unsigned I = 0, N = Name.size(); I != N; ++I) {
347  if (isIdentifierBody(Name[I]))
348  Buffer.push_back(Name[I]);
349  else
350  Buffer.push_back('_');
351  }
352 
353  Name = StringRef(Buffer.data(), Buffer.size());
354  }
355 
356  while (llvm::StringSwitch<bool>(Name)
357 #define KEYWORD(Keyword,Conditions) .Case(#Keyword, true)
358 #define ALIAS(Keyword, AliasOf, Conditions) .Case(Keyword, true)
359 #include "clang/Basic/TokenKinds.def"
360  .Default(false)) {
361  if (Name.data() != Buffer.data())
362  Buffer.append(Name.begin(), Name.end());
363  Buffer.push_back('_');
364  Name = StringRef(Buffer.data(), Buffer.size());
365  }
366 
367  return Name;
368 }
369 
370 /// Determine whether the given file name is the name of a builtin
371 /// header, supplied by Clang to replace, override, or augment existing system
372 /// headers.
373 bool ModuleMap::isBuiltinHeader(StringRef FileName) {
374  return llvm::StringSwitch<bool>(FileName)
375  .Case("float.h", true)
376  .Case("iso646.h", true)
377  .Case("limits.h", true)
378  .Case("stdalign.h", true)
379  .Case("stdarg.h", true)
380  .Case("stdatomic.h", true)
381  .Case("stdbool.h", true)
382  .Case("stddef.h", true)
383  .Case("stdint.h", true)
384  .Case("tgmath.h", true)
385  .Case("unwind.h", true)
386  .Default(false);
387 }
388 
389 ModuleMap::HeadersMap::iterator
390 ModuleMap::findKnownHeader(const FileEntry *File) {
392  HeadersMap::iterator Known = Headers.find(File);
393  if (HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps &&
394  Known == Headers.end() && File->getDir() == BuiltinIncludeDir &&
395  ModuleMap::isBuiltinHeader(llvm::sys::path::filename(File->getName()))) {
396  HeaderInfo.loadTopLevelSystemModules();
397  return Headers.find(File);
398  }
399  return Known;
400 }
401 
403 ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File,
404  SmallVectorImpl<const DirectoryEntry *> &IntermediateDirs) {
405  if (UmbrellaDirs.empty())
406  return {};
407 
408  const DirectoryEntry *Dir = File->getDir();
409  assert(Dir && "file in no directory");
410 
411  // Note: as an egregious but useful hack we use the real path here, because
412  // frameworks moving from top-level frameworks to embedded frameworks tend
413  // to be symlinked from the top-level location to the embedded location,
414  // and we need to resolve lookups as if we had found the embedded location.
415  StringRef DirName = SourceMgr.getFileManager().getCanonicalName(Dir);
416 
417  // Keep walking up the directory hierarchy, looking for a directory with
418  // an umbrella header.
419  do {
420  auto KnownDir = UmbrellaDirs.find(Dir);
421  if (KnownDir != UmbrellaDirs.end())
422  return KnownHeader(KnownDir->second, NormalHeader);
423 
424  IntermediateDirs.push_back(Dir);
425 
426  // Retrieve our parent path.
427  DirName = llvm::sys::path::parent_path(DirName);
428  if (DirName.empty())
429  break;
430 
431  // Resolve the parent path to a directory entry.
432  Dir = SourceMgr.getFileManager().getDirectory(DirName);
433  } while (Dir);
434  return {};
435 }
436 
437 static bool violatesPrivateInclude(Module *RequestingModule,
438  const FileEntry *IncFileEnt,
439  ModuleMap::KnownHeader Header) {
440 #ifndef NDEBUG
441  if (Header.getRole() & ModuleMap::PrivateHeader) {
442  // Check for consistency between the module header role
443  // as obtained from the lookup and as obtained from the module.
444  // This check is not cheap, so enable it only for debugging.
445  bool IsPrivate = false;
446  SmallVectorImpl<Module::Header> *HeaderList[] = {
449  for (auto *Hs : HeaderList)
450  IsPrivate |=
451  std::find_if(Hs->begin(), Hs->end(), [&](const Module::Header &H) {
452  return H.Entry == IncFileEnt;
453  }) != Hs->end();
454  assert(IsPrivate && "inconsistent headers and roles");
455  }
456 #endif
457  return !Header.isAccessibleFrom(RequestingModule);
458 }
459 
461  return M ? M->getTopLevelModule() : nullptr;
462 }
463 
465  bool RequestingModuleIsModuleInterface,
466  SourceLocation FilenameLoc,
467  StringRef Filename,
468  const FileEntry *File) {
469  // No errors for indirect modules. This may be a bit of a problem for modules
470  // with no source files.
471  if (getTopLevelOrNull(RequestingModule) != getTopLevelOrNull(SourceModule))
472  return;
473 
474  if (RequestingModule) {
475  resolveUses(RequestingModule, /*Complain=*/false);
476  resolveHeaderDirectives(RequestingModule);
477  }
478 
479  bool Excluded = false;
480  Module *Private = nullptr;
481  Module *NotUsed = nullptr;
482 
483  HeadersMap::iterator Known = findKnownHeader(File);
484  if (Known != Headers.end()) {
485  for (const KnownHeader &Header : Known->second) {
486  // Remember private headers for later printing of a diagnostic.
487  if (violatesPrivateInclude(RequestingModule, File, Header)) {
488  Private = Header.getModule();
489  continue;
490  }
491 
492  // If uses need to be specified explicitly, we are only allowed to return
493  // modules that are explicitly used by the requesting module.
494  if (RequestingModule && LangOpts.ModulesDeclUse &&
495  !RequestingModule->directlyUses(Header.getModule())) {
496  NotUsed = Header.getModule();
497  continue;
498  }
499 
500  // We have found a module that we can happily use.
501  return;
502  }
503 
504  Excluded = true;
505  }
506 
507  // We have found a header, but it is private.
508  if (Private) {
509  Diags.Report(FilenameLoc, diag::warn_use_of_private_header_outside_module)
510  << Filename;
511  return;
512  }
513 
514  // We have found a module, but we don't use it.
515  if (NotUsed) {
516  Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
517  << RequestingModule->getTopLevelModule()->Name << Filename;
518  return;
519  }
520 
521  if (Excluded || isHeaderInUmbrellaDirs(File))
522  return;
523 
524  // At this point, only non-modular includes remain.
525 
526  if (LangOpts.ModulesStrictDeclUse) {
527  Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module)
528  << RequestingModule->getTopLevelModule()->Name << Filename;
529  } else if (RequestingModule && RequestingModuleIsModuleInterface &&
530  LangOpts.isCompilingModule()) {
531  // Do not diagnose when we are not compiling a module.
532  diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ?
533  diag::warn_non_modular_include_in_framework_module :
534  diag::warn_non_modular_include_in_module;
535  Diags.Report(FilenameLoc, DiagID) << RequestingModule->getFullModuleName()
536  << File->getName();
537  }
538 }
539 
541  const ModuleMap::KnownHeader &Old) {
542  // Prefer available modules.
543  if (New.getModule()->isAvailable() && !Old.getModule()->isAvailable())
544  return true;
545 
546  // Prefer a public header over a private header.
547  if ((New.getRole() & ModuleMap::PrivateHeader) !=
549  return !(New.getRole() & ModuleMap::PrivateHeader);
550 
551  // Prefer a non-textual header over a textual header.
552  if ((New.getRole() & ModuleMap::TextualHeader) !=
554  return !(New.getRole() & ModuleMap::TextualHeader);
555 
556  // Don't have a reason to choose between these. Just keep the first one.
557  return false;
558 }
559 
561  bool AllowTextual) {
562  auto MakeResult = [&](ModuleMap::KnownHeader R) -> ModuleMap::KnownHeader {
563  if (!AllowTextual && R.getRole() & ModuleMap::TextualHeader)
564  return {};
565  return R;
566  };
567 
568  HeadersMap::iterator Known = findKnownHeader(File);
569  if (Known != Headers.end()) {
571  // Iterate over all modules that 'File' is part of to find the best fit.
572  for (KnownHeader &H : Known->second) {
573  // Prefer a header from the source module over all others.
574  if (H.getModule()->getTopLevelModule() == SourceModule)
575  return MakeResult(H);
576  if (!Result || isBetterKnownHeader(H, Result))
577  Result = H;
578  }
579  return MakeResult(Result);
580  }
581 
582  return MakeResult(findOrCreateModuleForHeaderInUmbrellaDir(File));
583 }
584 
586 ModuleMap::findOrCreateModuleForHeaderInUmbrellaDir(const FileEntry *File) {
587  assert(!Headers.count(File) && "already have a module for this header");
588 
590  KnownHeader H = findHeaderInUmbrellaDirs(File, SkippedDirs);
591  if (H) {
592  Module *Result = H.getModule();
593 
594  // Search up the module stack until we find a module with an umbrella
595  // directory.
596  Module *UmbrellaModule = Result;
597  while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
598  UmbrellaModule = UmbrellaModule->Parent;
599 
600  if (UmbrellaModule->InferSubmodules) {
601  const FileEntry *UmbrellaModuleMap =
602  getModuleMapFileForUniquing(UmbrellaModule);
603 
604  // Infer submodules for each of the directories we found between
605  // the directory of the umbrella header and the directory where
606  // the actual header is located.
607  bool Explicit = UmbrellaModule->InferExplicitSubmodules;
608 
609  for (unsigned I = SkippedDirs.size(); I != 0; --I) {
610  // Find or create the module that corresponds to this directory name.
611  SmallString<32> NameBuf;
612  StringRef Name = sanitizeFilenameAsIdentifier(
613  llvm::sys::path::stem(SkippedDirs[I-1]->getName()), NameBuf);
614  Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
615  Explicit).first;
616  InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
617  Result->IsInferred = true;
618 
619  // Associate the module and the directory.
620  UmbrellaDirs[SkippedDirs[I-1]] = Result;
621 
622  // If inferred submodules export everything they import, add a
623  // wildcard to the set of exports.
624  if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
625  Result->Exports.push_back(Module::ExportDecl(nullptr, true));
626  }
627 
628  // Infer a submodule with the same name as this header file.
629  SmallString<32> NameBuf;
630  StringRef Name = sanitizeFilenameAsIdentifier(
631  llvm::sys::path::stem(File->getName()), NameBuf);
632  Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
633  Explicit).first;
634  InferredModuleAllowedBy[Result] = UmbrellaModuleMap;
635  Result->IsInferred = true;
636  Result->addTopHeader(File);
637 
638  // If inferred submodules export everything they import, add a
639  // wildcard to the set of exports.
640  if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
641  Result->Exports.push_back(Module::ExportDecl(nullptr, true));
642  } else {
643  // Record each of the directories we stepped through as being part of
644  // the module we found, since the umbrella header covers them all.
645  for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
646  UmbrellaDirs[SkippedDirs[I]] = Result;
647  }
648 
649  KnownHeader Header(Result, NormalHeader);
650  Headers[File].push_back(Header);
651  return Header;
652  }
653 
654  return {};
655 }
656 
660  auto It = Headers.find(File);
661  if (It == Headers.end())
662  return None;
663  return It->second;
664 }
665 
667  return isHeaderUnavailableInModule(Header, nullptr);
668 }
669 
670 bool
672  const Module *RequestingModule) const {
673  resolveHeaderDirectives(Header);
674  HeadersMap::const_iterator Known = Headers.find(Header);
675  if (Known != Headers.end()) {
677  I = Known->second.begin(),
678  E = Known->second.end();
679  I != E; ++I) {
680 
681  if (I->isAvailable() &&
682  (!RequestingModule ||
683  I->getModule()->isSubModuleOf(RequestingModule))) {
684  // When no requesting module is available, the caller is looking if a
685  // header is part a module by only looking into the module map. This is
686  // done by warn_uncovered_module_header checks; don't consider textual
687  // headers part of it in this mode, otherwise we get misleading warnings
688  // that a umbrella header is not including a textual header.
689  if (!RequestingModule && I->getRole() == ModuleMap::TextualHeader)
690  continue;
691  return false;
692  }
693  }
694  return true;
695  }
696 
697  const DirectoryEntry *Dir = Header->getDir();
699  StringRef DirName = Dir->getName();
700 
701  auto IsUnavailable = [&](const Module *M) {
702  return !M->isAvailable() && (!RequestingModule ||
703  M->isSubModuleOf(RequestingModule));
704  };
705 
706  // Keep walking up the directory hierarchy, looking for a directory with
707  // an umbrella header.
708  do {
709  llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir
710  = UmbrellaDirs.find(Dir);
711  if (KnownDir != UmbrellaDirs.end()) {
712  Module *Found = KnownDir->second;
713  if (IsUnavailable(Found))
714  return true;
715 
716  // Search up the module stack until we find a module with an umbrella
717  // directory.
718  Module *UmbrellaModule = Found;
719  while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
720  UmbrellaModule = UmbrellaModule->Parent;
721 
722  if (UmbrellaModule->InferSubmodules) {
723  for (unsigned I = SkippedDirs.size(); I != 0; --I) {
724  // Find or create the module that corresponds to this directory name.
725  SmallString<32> NameBuf;
726  StringRef Name = sanitizeFilenameAsIdentifier(
727  llvm::sys::path::stem(SkippedDirs[I-1]->getName()),
728  NameBuf);
729  Found = lookupModuleQualified(Name, Found);
730  if (!Found)
731  return false;
732  if (IsUnavailable(Found))
733  return true;
734  }
735 
736  // Infer a submodule with the same name as this header file.
737  SmallString<32> NameBuf;
738  StringRef Name = sanitizeFilenameAsIdentifier(
739  llvm::sys::path::stem(Header->getName()),
740  NameBuf);
741  Found = lookupModuleQualified(Name, Found);
742  if (!Found)
743  return false;
744  }
745 
746  return IsUnavailable(Found);
747  }
748 
749  SkippedDirs.push_back(Dir);
750 
751  // Retrieve our parent path.
752  DirName = llvm::sys::path::parent_path(DirName);
753  if (DirName.empty())
754  break;
755 
756  // Resolve the parent path to a directory entry.
757  Dir = SourceMgr.getFileManager().getDirectory(DirName);
758  } while (Dir);
759 
760  return false;
761 }
762 
763 Module *ModuleMap::findModule(StringRef Name) const {
764  llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name);
765  if (Known != Modules.end())
766  return Known->getValue();
767 
768  return nullptr;
769 }
770 
772  Module *Context) const {
773  for(; Context; Context = Context->Parent) {
774  if (Module *Sub = lookupModuleQualified(Name, Context))
775  return Sub;
776  }
777 
778  return findModule(Name);
779 }
780 
781 Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{
782  if (!Context)
783  return findModule(Name);
784 
785  return Context->findSubmodule(Name);
786 }
787 
788 std::pair<Module *, bool> ModuleMap::findOrCreateModule(StringRef Name,
789  Module *Parent,
790  bool IsFramework,
791  bool IsExplicit) {
792  // Try to find an existing module with this name.
793  if (Module *Sub = lookupModuleQualified(Name, Parent))
794  return std::make_pair(Sub, false);
795 
796  // Create a new module with this name.
797  Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
798  IsExplicit, NumCreatedModules++);
799  if (!Parent) {
800  if (LangOpts.CurrentModule == Name)
801  SourceModule = Result;
802  Modules[Name] = Result;
803  ModuleScopeIDs[Result] = CurrentModuleScopeID;
804  }
805  return std::make_pair(Result, true);
806 }
807 
809  assert(!PendingGlobalModule && "created multiple global modules");
810  PendingGlobalModule.reset(
811  new Module("<global>", Loc, nullptr, /*IsFramework*/ false,
812  /*IsExplicit*/ true, NumCreatedModules++));
813  PendingGlobalModule->Kind = Module::GlobalModuleFragment;
814  return PendingGlobalModule.get();
815 }
816 
818  StringRef Name,
819  Module *GlobalModule) {
820  assert(LangOpts.CurrentModule == Name && "module name mismatch");
821  assert(!Modules[Name] && "redefining existing module");
822 
823  auto *Result =
824  new Module(Name, Loc, nullptr, /*IsFramework*/ false,
825  /*IsExplicit*/ false, NumCreatedModules++);
827  Modules[Name] = SourceModule = Result;
828 
829  // Reparent the current global module fragment as a submodule of this module.
830  assert(GlobalModule == PendingGlobalModule.get() &&
831  "unexpected global module");
832  GlobalModule->setParent(Result);
833  PendingGlobalModule.release(); // now owned by parent
834 
835  // Mark the main source file as being within the newly-created module so that
836  // declarations and macros are properly visibility-restricted to it.
837  auto *MainFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
838  assert(MainFile && "no input file for module interface");
839  Headers[MainFile].push_back(KnownHeader(Result, PrivateHeader));
840 
841  return Result;
842 }
843 
844 /// For a framework module, infer the framework against which we
845 /// should link.
846 static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir,
847  FileManager &FileMgr) {
848  assert(Mod->IsFramework && "Can only infer linking for framework modules");
849  assert(!Mod->isSubFramework() &&
850  "Can only infer linking for top-level frameworks");
851 
852  SmallString<128> LibName;
853  LibName += FrameworkDir->getName();
854  llvm::sys::path::append(LibName, Mod->Name);
855 
856  // The library name of a framework has more than one possible extension since
857  // the introduction of the text-based dynamic library format. We need to check
858  // for both before we give up.
859  for (const char *extension : {"", ".tbd"}) {
860  llvm::sys::path::replace_extension(LibName, extension);
861  if (FileMgr.getFile(LibName)) {
862  Mod->LinkLibraries.push_back(Module::LinkLibrary(Mod->Name,
863  /*IsFramework=*/true));
864  return;
865  }
866  }
867 }
868 
869 Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
870  bool IsSystem, Module *Parent) {
871  Attributes Attrs;
872  Attrs.IsSystem = IsSystem;
873  return inferFrameworkModule(FrameworkDir, Attrs, Parent);
874 }
875 
876 Module *ModuleMap::inferFrameworkModule(const DirectoryEntry *FrameworkDir,
877  Attributes Attrs, Module *Parent) {
878  // Note: as an egregious but useful hack we use the real path here, because
879  // we might be looking at an embedded framework that symlinks out to a
880  // top-level framework, and we need to infer as if we were naming the
881  // top-level framework.
882  StringRef FrameworkDirName =
883  SourceMgr.getFileManager().getCanonicalName(FrameworkDir);
884 
885  // In case this is a case-insensitive filesystem, use the canonical
886  // directory name as the ModuleName, since modules are case-sensitive.
887  // FIXME: we should be able to give a fix-it hint for the correct spelling.
888  SmallString<32> ModuleNameStorage;
889  StringRef ModuleName = sanitizeFilenameAsIdentifier(
890  llvm::sys::path::stem(FrameworkDirName), ModuleNameStorage);
891 
892  // Check whether we've already found this module.
893  if (Module *Mod = lookupModuleQualified(ModuleName, Parent))
894  return Mod;
895 
896  FileManager &FileMgr = SourceMgr.getFileManager();
897 
898  // If the framework has a parent path from which we're allowed to infer
899  // a framework module, do so.
900  const FileEntry *ModuleMapFile = nullptr;
901  if (!Parent) {
902  // Determine whether we're allowed to infer a module map.
903  bool canInfer = false;
904  if (llvm::sys::path::has_parent_path(FrameworkDirName)) {
905  // Figure out the parent path.
906  StringRef Parent = llvm::sys::path::parent_path(FrameworkDirName);
907  if (const DirectoryEntry *ParentDir = FileMgr.getDirectory(Parent)) {
908  // Check whether we have already looked into the parent directory
909  // for a module map.
910  llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
911  inferred = InferredDirectories.find(ParentDir);
912  if (inferred == InferredDirectories.end()) {
913  // We haven't looked here before. Load a module map, if there is
914  // one.
915  bool IsFrameworkDir = Parent.endswith(".framework");
916  if (const FileEntry *ModMapFile =
917  HeaderInfo.lookupModuleMapFile(ParentDir, IsFrameworkDir)) {
918  parseModuleMapFile(ModMapFile, Attrs.IsSystem, ParentDir);
919  inferred = InferredDirectories.find(ParentDir);
920  }
921 
922  if (inferred == InferredDirectories.end())
923  inferred = InferredDirectories.insert(
924  std::make_pair(ParentDir, InferredDirectory())).first;
925  }
926 
927  if (inferred->second.InferModules) {
928  // We're allowed to infer for this directory, but make sure it's okay
929  // to infer this particular module.
930  StringRef Name = llvm::sys::path::stem(FrameworkDirName);
931  canInfer = std::find(inferred->second.ExcludedModules.begin(),
932  inferred->second.ExcludedModules.end(),
933  Name) == inferred->second.ExcludedModules.end();
934 
935  Attrs.IsSystem |= inferred->second.Attrs.IsSystem;
936  Attrs.IsExternC |= inferred->second.Attrs.IsExternC;
937  Attrs.IsExhaustive |= inferred->second.Attrs.IsExhaustive;
938  Attrs.NoUndeclaredIncludes |=
939  inferred->second.Attrs.NoUndeclaredIncludes;
940  ModuleMapFile = inferred->second.ModuleMapFile;
941  }
942  }
943  }
944 
945  // If we're not allowed to infer a framework module, don't.
946  if (!canInfer)
947  return nullptr;
948  } else
949  ModuleMapFile = getModuleMapFileForUniquing(Parent);
950 
951 
952  // Look for an umbrella header.
953  SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
954  llvm::sys::path::append(UmbrellaName, "Headers", ModuleName + ".h");
955  const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName);
956 
957  // FIXME: If there's no umbrella header, we could probably scan the
958  // framework to load *everything*. But, it's not clear that this is a good
959  // idea.
960  if (!UmbrellaHeader)
961  return nullptr;
962 
963  Module *Result = new Module(ModuleName, SourceLocation(), Parent,
964  /*IsFramework=*/true, /*IsExplicit=*/false,
965  NumCreatedModules++);
966  InferredModuleAllowedBy[Result] = ModuleMapFile;
967  Result->IsInferred = true;
968  if (!Parent) {
969  if (LangOpts.CurrentModule == ModuleName)
970  SourceModule = Result;
971  Modules[ModuleName] = Result;
972  ModuleScopeIDs[Result] = CurrentModuleScopeID;
973  }
974 
975  Result->IsSystem |= Attrs.IsSystem;
976  Result->IsExternC |= Attrs.IsExternC;
977  Result->ConfigMacrosExhaustive |= Attrs.IsExhaustive;
978  Result->NoUndeclaredIncludes |= Attrs.NoUndeclaredIncludes;
979  Result->Directory = FrameworkDir;
980 
981  // umbrella header "umbrella-header-name"
982  //
983  // The "Headers/" component of the name is implied because this is
984  // a framework module.
985  setUmbrellaHeader(Result, UmbrellaHeader, ModuleName + ".h");
986 
987  // export *
988  Result->Exports.push_back(Module::ExportDecl(nullptr, true));
989 
990  // module * { export * }
991  Result->InferSubmodules = true;
992  Result->InferExportWildcard = true;
993 
994  // Look for subframeworks.
995  std::error_code EC;
996  SmallString<128> SubframeworksDirName
997  = StringRef(FrameworkDir->getName());
998  llvm::sys::path::append(SubframeworksDirName, "Frameworks");
999  llvm::sys::path::native(SubframeworksDirName);
1000  vfs::FileSystem &FS = *FileMgr.getVirtualFileSystem();
1001  for (vfs::directory_iterator Dir = FS.dir_begin(SubframeworksDirName, EC),
1002  DirEnd;
1003  Dir != DirEnd && !EC; Dir.increment(EC)) {
1004  if (!StringRef(Dir->getName()).endswith(".framework"))
1005  continue;
1006 
1007  if (const DirectoryEntry *SubframeworkDir =
1008  FileMgr.getDirectory(Dir->getName())) {
1009  // Note: as an egregious but useful hack, we use the real path here and
1010  // check whether it is actually a subdirectory of the parent directory.
1011  // This will not be the case if the 'subframework' is actually a symlink
1012  // out to a top-level framework.
1013  StringRef SubframeworkDirName = FileMgr.getCanonicalName(SubframeworkDir);
1014  bool FoundParent = false;
1015  do {
1016  // Get the parent directory name.
1017  SubframeworkDirName
1018  = llvm::sys::path::parent_path(SubframeworkDirName);
1019  if (SubframeworkDirName.empty())
1020  break;
1021 
1022  if (FileMgr.getDirectory(SubframeworkDirName) == FrameworkDir) {
1023  FoundParent = true;
1024  break;
1025  }
1026  } while (true);
1027 
1028  if (!FoundParent)
1029  continue;
1030 
1031  // FIXME: Do we want to warn about subframeworks without umbrella headers?
1032  inferFrameworkModule(SubframeworkDir, Attrs, Result);
1033  }
1034  }
1035 
1036  // If the module is a top-level framework, automatically link against the
1037  // framework.
1038  if (!Result->isSubFramework()) {
1039  inferFrameworkLink(Result, FrameworkDir, FileMgr);
1040  }
1041 
1042  return Result;
1043 }
1044 
1045 Module *ModuleMap::createShadowedModule(StringRef Name, bool IsFramework,
1046  Module *ShadowingModule) {
1047 
1048  // Create a new module with this name.
1049  Module *Result =
1050  new Module(Name, SourceLocation(), /*Parent=*/nullptr, IsFramework,
1051  /*IsExplicit=*/false, NumCreatedModules++);
1052  Result->ShadowingModule = ShadowingModule;
1053  Result->IsAvailable = false;
1054  ModuleScopeIDs[Result] = CurrentModuleScopeID;
1055  ShadowModules.push_back(Result);
1056 
1057  return Result;
1058 }
1059 
1060 void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader,
1061  Twine NameAsWritten) {
1062  Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader));
1063  Mod->Umbrella = UmbrellaHeader;
1064  Mod->UmbrellaAsWritten = NameAsWritten.str();
1065  UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
1066 
1067  // Notify callbacks that we just added a new header.
1068  for (const auto &Cb : Callbacks)
1069  Cb->moduleMapAddUmbrellaHeader(&SourceMgr.getFileManager(), UmbrellaHeader);
1070 }
1071 
1072 void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir,
1073  Twine NameAsWritten) {
1074  Mod->Umbrella = UmbrellaDir;
1075  Mod->UmbrellaAsWritten = NameAsWritten.str();
1076  UmbrellaDirs[UmbrellaDir] = Mod;
1077 }
1078 
1079 void ModuleMap::addUnresolvedHeader(Module *Mod,
1081  bool &NeedsFramework) {
1082  // If there is a builtin counterpart to this file, add it now so it can
1083  // wrap the system header.
1084  if (resolveAsBuiltinHeader(Mod, Header)) {
1085  // If we have both a builtin and system version of the file, the
1086  // builtin version may want to inject macros into the system header, so
1087  // force the system header to be treated as a textual header in this
1088  // case.
1091  Header.HasBuiltinHeader = true;
1092  }
1093 
1094  // If possible, don't stat the header until we need to. This requires the
1095  // user to have provided us with some stat information about the file.
1096  // FIXME: Add support for lazily stat'ing umbrella headers and excluded
1097  // headers.
1098  if ((Header.Size || Header.ModTime) && !Header.IsUmbrella &&
1099  Header.Kind != Module::HK_Excluded) {
1100  // We expect more variation in mtime than size, so if we're given both,
1101  // use the mtime as the key.
1102  if (Header.ModTime)
1103  LazyHeadersByModTime[*Header.ModTime].push_back(Mod);
1104  else
1105  LazyHeadersBySize[*Header.Size].push_back(Mod);
1106  Mod->UnresolvedHeaders.push_back(Header);
1107  return;
1108  }
1109 
1110  // We don't have stat information or can't defer looking this file up.
1111  // Perform the lookup now.
1112  resolveHeader(Mod, Header, NeedsFramework);
1113 }
1114 
1116  auto BySize = LazyHeadersBySize.find(File->getSize());
1117  if (BySize != LazyHeadersBySize.end()) {
1118  for (auto *M : BySize->second)
1120  LazyHeadersBySize.erase(BySize);
1121  }
1122 
1123  auto ByModTime = LazyHeadersByModTime.find(File->getModificationTime());
1124  if (ByModTime != LazyHeadersByModTime.end()) {
1125  for (auto *M : ByModTime->second)
1127  LazyHeadersByModTime.erase(ByModTime);
1128  }
1129 }
1130 
1132  bool NeedsFramework = false;
1133  for (auto &Header : Mod->UnresolvedHeaders)
1134  // This operation is logically const; we're just changing how we represent
1135  // the header information for this file.
1136  const_cast<ModuleMap*>(this)->resolveHeader(Mod, Header, NeedsFramework);
1137  Mod->UnresolvedHeaders.clear();
1138 }
1139 
1141  ModuleHeaderRole Role, bool Imported) {
1142  KnownHeader KH(Mod, Role);
1143 
1144  // Only add each header to the headers list once.
1145  // FIXME: Should we diagnose if a header is listed twice in the
1146  // same module definition?
1147  auto &HeaderList = Headers[Header.Entry];
1148  for (auto H : HeaderList)
1149  if (H == KH)
1150  return;
1151 
1152  HeaderList.push_back(KH);
1153  Mod->Headers[headerRoleToKind(Role)].push_back(Header);
1154 
1155  bool isCompilingModuleHeader =
1156  LangOpts.isCompilingModule() && Mod->getTopLevelModule() == SourceModule;
1157  if (!Imported || isCompilingModuleHeader) {
1158  // When we import HeaderFileInfo, the external source is expected to
1159  // set the isModuleHeader flag itself.
1160  HeaderInfo.MarkFileModuleHeader(Header.Entry, Role,
1161  isCompilingModuleHeader);
1162  }
1163 
1164  // Notify callbacks that we just added a new header.
1165  for (const auto &Cb : Callbacks)
1166  Cb->moduleMapAddHeader(Header.Entry->getName());
1167 }
1168 
1170  // Add this as a known header so we won't implicitly add it to any
1171  // umbrella directory module.
1172  // FIXME: Should we only exclude it from umbrella modules within the
1173  // specified module?
1174  (void) Headers[Header.Entry];
1175 
1176  Mod->Headers[Module::HK_Excluded].push_back(std::move(Header));
1177 }
1178 
1179 const FileEntry *
1181  if (Module->DefinitionLoc.isInvalid())
1182  return nullptr;
1183 
1184  return SourceMgr.getFileEntryForID(
1185  SourceMgr.getFileID(Module->DefinitionLoc));
1186 }
1187 
1189  if (M->IsInferred) {
1190  assert(InferredModuleAllowedBy.count(M) && "missing inferred module map");
1191  return InferredModuleAllowedBy.find(M)->second;
1192  }
1193  return getContainingModuleMapFile(M);
1194 }
1195 
1197  assert(M->IsInferred && "module not inferred");
1198  InferredModuleAllowedBy[M] = ModMap;
1199 }
1200 
1201 LLVM_DUMP_METHOD void ModuleMap::dump() {
1202  llvm::errs() << "Modules:";
1203  for (llvm::StringMap<Module *>::iterator M = Modules.begin(),
1204  MEnd = Modules.end();
1205  M != MEnd; ++M)
1206  M->getValue()->print(llvm::errs(), 2);
1207 
1208  llvm::errs() << "Headers:";
1209  for (HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end();
1210  H != HEnd; ++H) {
1211  llvm::errs() << " \"" << H->first->getName() << "\" -> ";
1212  for (SmallVectorImpl<KnownHeader>::const_iterator I = H->second.begin(),
1213  E = H->second.end();
1214  I != E; ++I) {
1215  if (I != H->second.begin())
1216  llvm::errs() << ",";
1217  llvm::errs() << I->getModule()->getFullModuleName();
1218  }
1219  llvm::errs() << "\n";
1220  }
1221 }
1222 
1223 bool ModuleMap::resolveExports(Module *Mod, bool Complain) {
1224  auto Unresolved = std::move(Mod->UnresolvedExports);
1225  Mod->UnresolvedExports.clear();
1226  for (auto &UE : Unresolved) {
1227  Module::ExportDecl Export = resolveExport(Mod, UE, Complain);
1228  if (Export.getPointer() || Export.getInt())
1229  Mod->Exports.push_back(Export);
1230  else
1231  Mod->UnresolvedExports.push_back(UE);
1232  }
1233  return !Mod->UnresolvedExports.empty();
1234 }
1235 
1236 bool ModuleMap::resolveUses(Module *Mod, bool Complain) {
1237  auto Unresolved = std::move(Mod->UnresolvedDirectUses);
1238  Mod->UnresolvedDirectUses.clear();
1239  for (auto &UDU : Unresolved) {
1240  Module *DirectUse = resolveModuleId(UDU, Mod, Complain);
1241  if (DirectUse)
1242  Mod->DirectUses.push_back(DirectUse);
1243  else
1244  Mod->UnresolvedDirectUses.push_back(UDU);
1245  }
1246  return !Mod->UnresolvedDirectUses.empty();
1247 }
1248 
1249 bool ModuleMap::resolveConflicts(Module *Mod, bool Complain) {
1250  auto Unresolved = std::move(Mod->UnresolvedConflicts);
1251  Mod->UnresolvedConflicts.clear();
1252  for (auto &UC : Unresolved) {
1253  if (Module *OtherMod = resolveModuleId(UC.Id, Mod, Complain)) {
1254  Module::Conflict Conflict;
1255  Conflict.Other = OtherMod;
1256  Conflict.Message = UC.Message;
1257  Mod->Conflicts.push_back(Conflict);
1258  } else
1259  Mod->UnresolvedConflicts.push_back(UC);
1260  }
1261  return !Mod->UnresolvedConflicts.empty();
1262 }
1263 
1264 //----------------------------------------------------------------------------//
1265 // Module map file parser
1266 //----------------------------------------------------------------------------//
1267 
1268 namespace clang {
1269 
1270  /// A token in a module map file.
1271  struct MMToken {
1272  enum TokenKind {
1300  RSquare
1301  } Kind;
1302 
1303  unsigned Location;
1304  unsigned StringLength;
1305  union {
1306  // If Kind != IntegerLiteral.
1307  const char *StringData;
1308 
1309  // If Kind == IntegerLiteral.
1310  uint64_t IntegerValue;
1311  };
1312 
1313  void clear() {
1314  Kind = EndOfFile;
1315  Location = 0;
1316  StringLength = 0;
1317  StringData = nullptr;
1318  }
1319 
1320  bool is(TokenKind K) const { return Kind == K; }
1321 
1323  return SourceLocation::getFromRawEncoding(Location);
1324  }
1325 
1326  uint64_t getInteger() const {
1327  return Kind == IntegerLiteral ? IntegerValue : 0;
1328  }
1329 
1330  StringRef getString() const {
1331  return Kind == IntegerLiteral ? StringRef()
1332  : StringRef(StringData, StringLength);
1333  }
1334  };
1335 
1337  Lexer &L;
1338  SourceManager &SourceMgr;
1339 
1340  /// Default target information, used only for string literal
1341  /// parsing.
1342  const TargetInfo *Target;
1343 
1344  DiagnosticsEngine &Diags;
1345  ModuleMap &Map;
1346 
1347  /// The current module map file.
1348  const FileEntry *ModuleMapFile;
1349 
1350  /// Source location of most recent parsed module declaration
1351  SourceLocation CurrModuleDeclLoc;
1352 
1353  /// The directory that file names in this module map file should
1354  /// be resolved relative to.
1355  const DirectoryEntry *Directory;
1356 
1357  /// Whether this module map is in a system header directory.
1358  bool IsSystem;
1359 
1360  /// Whether an error occurred.
1361  bool HadError = false;
1362 
1363  /// Stores string data for the various string literals referenced
1364  /// during parsing.
1365  llvm::BumpPtrAllocator StringData;
1366 
1367  /// The current token.
1368  MMToken Tok;
1369 
1370  /// The active module.
1371  Module *ActiveModule = nullptr;
1372 
1373  /// Whether a module uses the 'requires excluded' hack to mark its
1374  /// contents as 'textual'.
1375  ///
1376  /// On older Darwin SDK versions, 'requires excluded' is used to mark the
1377  /// contents of the Darwin.C.excluded (assert.h) and Tcl.Private modules as
1378  /// non-modular headers. For backwards compatibility, we continue to
1379  /// support this idiom for just these modules, and map the headers to
1380  /// 'textual' to match the original intent.
1381  llvm::SmallPtrSet<Module *, 2> UsesRequiresExcludedHack;
1382 
1383  /// Consume the current token and return its location.
1384  SourceLocation consumeToken();
1385 
1386  /// Skip tokens until we reach the a token with the given kind
1387  /// (or the end of the file).
1388  void skipUntil(MMToken::TokenKind K);
1389 
1391 
1392  bool parseModuleId(ModuleId &Id);
1393  void parseModuleDecl();
1394  void parseExternModuleDecl();
1395  void parseRequiresDecl();
1396  void parseHeaderDecl(MMToken::TokenKind, SourceLocation LeadingLoc);
1397  void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc);
1398  void parseExportDecl();
1399  void parseExportAsDecl();
1400  void parseUseDecl();
1401  void parseLinkDecl();
1402  void parseConfigMacros();
1403  void parseConflict();
1404  void parseInferredModuleDecl(bool Framework, bool Explicit);
1405 
1406  /// Private modules are canonicalized as Foo_Private. Clang provides extra
1407  /// module map search logic to find the appropriate private module when PCH
1408  /// is used with implicit module maps. Warn when private modules are written
1409  /// in other ways (FooPrivate and Foo.Private), providing notes and fixits.
1410  void diagnosePrivateModules(SourceLocation ExplicitLoc,
1411  SourceLocation FrameworkLoc);
1412 
1413  using Attributes = ModuleMap::Attributes;
1414 
1415  bool parseOptionalAttributes(Attributes &Attrs);
1416 
1417  public:
1418  explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
1419  const TargetInfo *Target, DiagnosticsEngine &Diags,
1420  ModuleMap &Map, const FileEntry *ModuleMapFile,
1421  const DirectoryEntry *Directory, bool IsSystem)
1422  : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
1423  ModuleMapFile(ModuleMapFile), Directory(Directory),
1424  IsSystem(IsSystem) {
1425  Tok.clear();
1426  consumeToken();
1427  }
1428 
1429  bool parseModuleMapFile();
1430 
1431  bool terminatedByDirective() { return false; }
1433  };
1434 
1435 } // namespace clang
1436 
1437 SourceLocation ModuleMapParser::consumeToken() {
1438  SourceLocation Result = Tok.getLocation();
1439 
1440 retry:
1441  Tok.clear();
1442  Token LToken;
1443  L.LexFromRawLexer(LToken);
1444  Tok.Location = LToken.getLocation().getRawEncoding();
1445  switch (LToken.getKind()) {
1446  case tok::raw_identifier: {
1447  StringRef RI = LToken.getRawIdentifier();
1448  Tok.StringData = RI.data();
1449  Tok.StringLength = RI.size();
1450  Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(RI)
1451  .Case("config_macros", MMToken::ConfigMacros)
1452  .Case("conflict", MMToken::Conflict)
1453  .Case("exclude", MMToken::ExcludeKeyword)
1454  .Case("explicit", MMToken::ExplicitKeyword)
1455  .Case("export", MMToken::ExportKeyword)
1456  .Case("export_as", MMToken::ExportAsKeyword)
1457  .Case("extern", MMToken::ExternKeyword)
1458  .Case("framework", MMToken::FrameworkKeyword)
1459  .Case("header", MMToken::HeaderKeyword)
1460  .Case("link", MMToken::LinkKeyword)
1461  .Case("module", MMToken::ModuleKeyword)
1462  .Case("private", MMToken::PrivateKeyword)
1463  .Case("requires", MMToken::RequiresKeyword)
1464  .Case("textual", MMToken::TextualKeyword)
1465  .Case("umbrella", MMToken::UmbrellaKeyword)
1466  .Case("use", MMToken::UseKeyword)
1467  .Default(MMToken::Identifier);
1468  break;
1469  }
1470 
1471  case tok::comma:
1472  Tok.Kind = MMToken::Comma;
1473  break;
1474 
1475  case tok::eof:
1476  Tok.Kind = MMToken::EndOfFile;
1477  break;
1478 
1479  case tok::l_brace:
1480  Tok.Kind = MMToken::LBrace;
1481  break;
1482 
1483  case tok::l_square:
1484  Tok.Kind = MMToken::LSquare;
1485  break;
1486 
1487  case tok::period:
1488  Tok.Kind = MMToken::Period;
1489  break;
1490 
1491  case tok::r_brace:
1492  Tok.Kind = MMToken::RBrace;
1493  break;
1494 
1495  case tok::r_square:
1496  Tok.Kind = MMToken::RSquare;
1497  break;
1498 
1499  case tok::star:
1500  Tok.Kind = MMToken::Star;
1501  break;
1502 
1503  case tok::exclaim:
1504  Tok.Kind = MMToken::Exclaim;
1505  break;
1506 
1507  case tok::string_literal: {
1508  if (LToken.hasUDSuffix()) {
1509  Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl);
1510  HadError = true;
1511  goto retry;
1512  }
1513 
1514  // Parse the string literal.
1515  LangOptions LangOpts;
1516  StringLiteralParser StringLiteral(LToken, SourceMgr, LangOpts, *Target);
1517  if (StringLiteral.hadError)
1518  goto retry;
1519 
1520  // Copy the string literal into our string data allocator.
1521  unsigned Length = StringLiteral.GetStringLength();
1522  char *Saved = StringData.Allocate<char>(Length + 1);
1523  memcpy(Saved, StringLiteral.GetString().data(), Length);
1524  Saved[Length] = 0;
1525 
1526  // Form the token.
1527  Tok.Kind = MMToken::StringLiteral;
1528  Tok.StringData = Saved;
1529  Tok.StringLength = Length;
1530  break;
1531  }
1532 
1533  case tok::numeric_constant: {
1534  // We don't support any suffixes or other complications.
1535  SmallString<32> SpellingBuffer;
1536  SpellingBuffer.resize(LToken.getLength() + 1);
1537  const char *Start = SpellingBuffer.data();
1538  unsigned Length =
1539  Lexer::getSpelling(LToken, Start, SourceMgr, L.getLangOpts());
1540  uint64_t Value;
1541  if (StringRef(Start, Length).getAsInteger(0, Value)) {
1542  Diags.Report(Tok.getLocation(), diag::err_mmap_unknown_token);
1543  HadError = true;
1544  goto retry;
1545  }
1546 
1548  Tok.IntegerValue = Value;
1549  break;
1550  }
1551 
1552  case tok::comment:
1553  goto retry;
1554 
1555  case tok::hash:
1556  // A module map can be terminated prematurely by
1557  // #pragma clang module contents
1558  // When building the module, we'll treat the rest of the file as the
1559  // contents of the module.
1560  {
1561  auto NextIsIdent = [&](StringRef Str) -> bool {
1562  L.LexFromRawLexer(LToken);
1563  return !LToken.isAtStartOfLine() && LToken.is(tok::raw_identifier) &&
1564  LToken.getRawIdentifier() == Str;
1565  };
1566  if (NextIsIdent("pragma") && NextIsIdent("clang") &&
1567  NextIsIdent("module") && NextIsIdent("contents")) {
1568  Tok.Kind = MMToken::EndOfFile;
1569  break;
1570  }
1571  }
1572  LLVM_FALLTHROUGH;
1573 
1574  default:
1575  Diags.Report(Tok.getLocation(), diag::err_mmap_unknown_token);
1576  HadError = true;
1577  goto retry;
1578  }
1579 
1580  return Result;
1581 }
1582 
1583 void ModuleMapParser::skipUntil(MMToken::TokenKind K) {
1584  unsigned braceDepth = 0;
1585  unsigned squareDepth = 0;
1586  do {
1587  switch (Tok.Kind) {
1588  case MMToken::EndOfFile:
1589  return;
1590 
1591  case MMToken::LBrace:
1592  if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1593  return;
1594 
1595  ++braceDepth;
1596  break;
1597 
1598  case MMToken::LSquare:
1599  if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
1600  return;
1601 
1602  ++squareDepth;
1603  break;
1604 
1605  case MMToken::RBrace:
1606  if (braceDepth > 0)
1607  --braceDepth;
1608  else if (Tok.is(K))
1609  return;
1610  break;
1611 
1612  case MMToken::RSquare:
1613  if (squareDepth > 0)
1614  --squareDepth;
1615  else if (Tok.is(K))
1616  return;
1617  break;
1618 
1619  default:
1620  if (braceDepth == 0 && squareDepth == 0 && Tok.is(K))
1621  return;
1622  break;
1623  }
1624 
1625  consumeToken();
1626  } while (true);
1627 }
1628 
1629 /// Parse a module-id.
1630 ///
1631 /// module-id:
1632 /// identifier
1633 /// identifier '.' module-id
1634 ///
1635 /// \returns true if an error occurred, false otherwise.
1636 bool ModuleMapParser::parseModuleId(ModuleId &Id) {
1637  Id.clear();
1638  do {
1640  Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation()));
1641  consumeToken();
1642  } else {
1643  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name);
1644  return true;
1645  }
1646 
1647  if (!Tok.is(MMToken::Period))
1648  break;
1649 
1650  consumeToken();
1651  } while (true);
1652 
1653  return false;
1654 }
1655 
1656 namespace {
1657 
1658  /// Enumerates the known attributes.
1660  /// An unknown attribute.
1661  AT_unknown,
1662 
1663  /// The 'system' attribute.
1664  AT_system,
1665 
1666  /// The 'extern_c' attribute.
1667  AT_extern_c,
1668 
1669  /// The 'exhaustive' attribute.
1670  AT_exhaustive,
1671 
1672  /// The 'no_undeclared_includes' attribute.
1673  AT_no_undeclared_includes
1674  };
1675 
1676 } // namespace
1677 
1678 /// Private modules are canonicalized as Foo_Private. Clang provides extra
1679 /// module map search logic to find the appropriate private module when PCH
1680 /// is used with implicit module maps. Warn when private modules are written
1681 /// in other ways (FooPrivate and Foo.Private), providing notes and fixits.
1682 void ModuleMapParser::diagnosePrivateModules(SourceLocation ExplicitLoc,
1683  SourceLocation FrameworkLoc) {
1684  auto GenNoteAndFixIt = [&](StringRef BadName, StringRef Canonical,
1685  const Module *M, SourceRange ReplLoc) {
1686  auto D = Diags.Report(ActiveModule->DefinitionLoc,
1687  diag::note_mmap_rename_top_level_private_module);
1688  D << BadName << M->Name;
1689  D << FixItHint::CreateReplacement(ReplLoc, Canonical);
1690  };
1691 
1692  for (auto E = Map.module_begin(); E != Map.module_end(); ++E) {
1693  auto const *M = E->getValue();
1694  if (M->Directory != ActiveModule->Directory)
1695  continue;
1696 
1697  SmallString<128> FullName(ActiveModule->getFullModuleName());
1698  if (!FullName.startswith(M->Name) && !FullName.endswith("Private"))
1699  continue;
1700  SmallString<128> FixedPrivModDecl;
1701  SmallString<128> Canonical(M->Name);
1702  Canonical.append("_Private");
1703 
1704  // Foo.Private -> Foo_Private
1705  if (ActiveModule->Parent && ActiveModule->Name == "Private" && !M->Parent &&
1706  M->Name == ActiveModule->Parent->Name) {
1707  Diags.Report(ActiveModule->DefinitionLoc,
1708  diag::warn_mmap_mismatched_private_submodule)
1709  << FullName;
1710 
1711  SourceLocation FixItInitBegin = CurrModuleDeclLoc;
1712  if (FrameworkLoc.isValid())
1713  FixItInitBegin = FrameworkLoc;
1714  if (ExplicitLoc.isValid())
1715  FixItInitBegin = ExplicitLoc;
1716 
1717  if (FrameworkLoc.isValid() || ActiveModule->Parent->IsFramework)
1718  FixedPrivModDecl.append("framework ");
1719  FixedPrivModDecl.append("module ");
1720  FixedPrivModDecl.append(Canonical);
1721 
1722  GenNoteAndFixIt(FullName, FixedPrivModDecl, M,
1723  SourceRange(FixItInitBegin, ActiveModule->DefinitionLoc));
1724  continue;
1725  }
1726 
1727  // FooPrivate and whatnots -> Foo_Private
1728  if (!ActiveModule->Parent && !M->Parent && M->Name != ActiveModule->Name &&
1729  ActiveModule->Name != Canonical) {
1730  Diags.Report(ActiveModule->DefinitionLoc,
1731  diag::warn_mmap_mismatched_private_module_name)
1732  << ActiveModule->Name;
1733  GenNoteAndFixIt(ActiveModule->Name, Canonical, M,
1734  SourceRange(ActiveModule->DefinitionLoc));
1735  }
1736  }
1737 }
1738 
1739 /// Parse a module declaration.
1740 ///
1741 /// module-declaration:
1742 /// 'extern' 'module' module-id string-literal
1743 /// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt]
1744 /// { module-member* }
1745 ///
1746 /// module-member:
1747 /// requires-declaration
1748 /// header-declaration
1749 /// submodule-declaration
1750 /// export-declaration
1751 /// export-as-declaration
1752 /// link-declaration
1753 ///
1754 /// submodule-declaration:
1755 /// module-declaration
1756 /// inferred-submodule-declaration
1757 void ModuleMapParser::parseModuleDecl() {
1760  if (Tok.is(MMToken::ExternKeyword)) {
1761  parseExternModuleDecl();
1762  return;
1763  }
1764 
1765  // Parse 'explicit' or 'framework' keyword, if present.
1766  SourceLocation ExplicitLoc;
1767  SourceLocation FrameworkLoc;
1768  bool Explicit = false;
1769  bool Framework = false;
1770 
1771  // Parse 'explicit' keyword, if present.
1773  ExplicitLoc = consumeToken();
1774  Explicit = true;
1775  }
1776 
1777  // Parse 'framework' keyword, if present.
1779  FrameworkLoc = consumeToken();
1780  Framework = true;
1781  }
1782 
1783  // Parse 'module' keyword.
1784  if (!Tok.is(MMToken::ModuleKeyword)) {
1785  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1786  consumeToken();
1787  HadError = true;
1788  return;
1789  }
1790  CurrModuleDeclLoc = consumeToken(); // 'module' keyword
1791 
1792  // If we have a wildcard for the module name, this is an inferred submodule.
1793  // Parse it.
1794  if (Tok.is(MMToken::Star))
1795  return parseInferredModuleDecl(Framework, Explicit);
1796 
1797  // Parse the module name.
1798  ModuleId Id;
1799  if (parseModuleId(Id)) {
1800  HadError = true;
1801  return;
1802  }
1803 
1804  if (ActiveModule) {
1805  if (Id.size() > 1) {
1806  Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id)
1807  << SourceRange(Id.front().second, Id.back().second);
1808 
1809  HadError = true;
1810  return;
1811  }
1812  } else if (Id.size() == 1 && Explicit) {
1813  // Top-level modules can't be explicit.
1814  Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level);
1815  Explicit = false;
1816  ExplicitLoc = SourceLocation();
1817  HadError = true;
1818  }
1819 
1820  Module *PreviousActiveModule = ActiveModule;
1821  if (Id.size() > 1) {
1822  // This module map defines a submodule. Go find the module of which it
1823  // is a submodule.
1824  ActiveModule = nullptr;
1825  const Module *TopLevelModule = nullptr;
1826  for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) {
1827  if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) {
1828  if (I == 0)
1829  TopLevelModule = Next;
1830  ActiveModule = Next;
1831  continue;
1832  }
1833 
1834  if (ActiveModule) {
1835  Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
1836  << Id[I].first
1837  << ActiveModule->getTopLevelModule()->getFullModuleName();
1838  } else {
1839  Diags.Report(Id[I].second, diag::err_mmap_expected_module_name);
1840  }
1841  HadError = true;
1842  return;
1843  }
1844 
1845  if (ModuleMapFile != Map.getContainingModuleMapFile(TopLevelModule)) {
1846  assert(ModuleMapFile != Map.getModuleMapFileForUniquing(TopLevelModule) &&
1847  "submodule defined in same file as 'module *' that allowed its "
1848  "top-level module");
1849  Map.addAdditionalModuleMapFile(TopLevelModule, ModuleMapFile);
1850  }
1851  }
1852 
1853  StringRef ModuleName = Id.back().first;
1854  SourceLocation ModuleNameLoc = Id.back().second;
1855 
1856  // Parse the optional attribute list.
1857  Attributes Attrs;
1858  if (parseOptionalAttributes(Attrs))
1859  return;
1860 
1861  // Parse the opening brace.
1862  if (!Tok.is(MMToken::LBrace)) {
1863  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
1864  << ModuleName;
1865  HadError = true;
1866  return;
1867  }
1868  SourceLocation LBraceLoc = consumeToken();
1869 
1870  // Determine whether this (sub)module has already been defined.
1871  Module *ShadowingModule = nullptr;
1872  if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
1873  // We might see a (re)definition of a module that we already have a
1874  // definition for in two cases:
1875  // - If we loaded one definition from an AST file and we've just found a
1876  // corresponding definition in a module map file, or
1877  bool LoadedFromASTFile = Existing->DefinitionLoc.isInvalid();
1878  // - If we're building a (preprocessed) module and we've just loaded the
1879  // module map file from which it was created.
1880  bool ParsedAsMainInput =
1881  Map.LangOpts.getCompilingModule() == LangOptions::CMK_ModuleMap &&
1882  Map.LangOpts.CurrentModule == ModuleName &&
1883  SourceMgr.getDecomposedLoc(ModuleNameLoc).first !=
1884  SourceMgr.getDecomposedLoc(Existing->DefinitionLoc).first;
1885  if (!ActiveModule && (LoadedFromASTFile || ParsedAsMainInput)) {
1886  // Skip the module definition.
1887  skipUntil(MMToken::RBrace);
1888  if (Tok.is(MMToken::RBrace))
1889  consumeToken();
1890  else {
1891  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1892  Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1893  HadError = true;
1894  }
1895  return;
1896  }
1897 
1898  if (!Existing->Parent && Map.mayShadowNewModule(Existing)) {
1899  ShadowingModule = Existing;
1900  } else {
1901  // This is not a shawdowed module decl, it is an illegal redefinition.
1902  Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
1903  << ModuleName;
1904  Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition);
1905 
1906  // Skip the module definition.
1907  skipUntil(MMToken::RBrace);
1908  if (Tok.is(MMToken::RBrace))
1909  consumeToken();
1910 
1911  HadError = true;
1912  return;
1913  }
1914  }
1915 
1916  // Start defining this module.
1917  if (ShadowingModule) {
1918  ActiveModule =
1919  Map.createShadowedModule(ModuleName, Framework, ShadowingModule);
1920  } else {
1921  ActiveModule =
1922  Map.findOrCreateModule(ModuleName, ActiveModule, Framework, Explicit)
1923  .first;
1924  }
1925 
1926  ActiveModule->DefinitionLoc = ModuleNameLoc;
1927  if (Attrs.IsSystem || IsSystem)
1928  ActiveModule->IsSystem = true;
1929  if (Attrs.IsExternC)
1930  ActiveModule->IsExternC = true;
1931  if (Attrs.NoUndeclaredIncludes ||
1932  (!ActiveModule->Parent && ModuleName == "Darwin"))
1933  ActiveModule->NoUndeclaredIncludes = true;
1934  ActiveModule->Directory = Directory;
1935 
1936  StringRef MapFileName(ModuleMapFile->getName());
1937  if (MapFileName.endswith("module.private.modulemap") ||
1938  MapFileName.endswith("module_private.map")) {
1939  ActiveModule->ModuleMapIsPrivate = true;
1940  }
1941 
1942  // Private modules named as FooPrivate, Foo.Private or similar are likely a
1943  // user error; provide warnings, notes and fixits to direct users to use
1944  // Foo_Private instead.
1945  SourceLocation StartLoc =
1946  SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1947  if (Map.HeaderInfo.getHeaderSearchOpts().ImplicitModuleMaps &&
1948  !Diags.isIgnored(diag::warn_mmap_mismatched_private_submodule,
1949  StartLoc) &&
1950  !Diags.isIgnored(diag::warn_mmap_mismatched_private_module_name,
1951  StartLoc) &&
1952  ActiveModule->ModuleMapIsPrivate)
1953  diagnosePrivateModules(ExplicitLoc, FrameworkLoc);
1954 
1955  bool Done = false;
1956  do {
1957  switch (Tok.Kind) {
1958  case MMToken::EndOfFile:
1959  case MMToken::RBrace:
1960  Done = true;
1961  break;
1962 
1963  case MMToken::ConfigMacros:
1964  parseConfigMacros();
1965  break;
1966 
1967  case MMToken::Conflict:
1968  parseConflict();
1969  break;
1970 
1975  parseModuleDecl();
1976  break;
1977 
1979  parseExportDecl();
1980  break;
1981 
1983  parseExportAsDecl();
1984  break;
1985 
1986  case MMToken::UseKeyword:
1987  parseUseDecl();
1988  break;
1989 
1991  parseRequiresDecl();
1992  break;
1993 
1995  parseHeaderDecl(MMToken::TextualKeyword, consumeToken());
1996  break;
1997 
1998  case MMToken::UmbrellaKeyword: {
1999  SourceLocation UmbrellaLoc = consumeToken();
2001  parseHeaderDecl(MMToken::UmbrellaKeyword, UmbrellaLoc);
2002  else
2003  parseUmbrellaDirDecl(UmbrellaLoc);
2004  break;
2005  }
2006 
2008  parseHeaderDecl(MMToken::ExcludeKeyword, consumeToken());
2009  break;
2010 
2012  parseHeaderDecl(MMToken::PrivateKeyword, consumeToken());
2013  break;
2014 
2016  parseHeaderDecl(MMToken::HeaderKeyword, consumeToken());
2017  break;
2018 
2019  case MMToken::LinkKeyword:
2020  parseLinkDecl();
2021  break;
2022 
2023  default:
2024  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member);
2025  consumeToken();
2026  break;
2027  }
2028  } while (!Done);
2029 
2030  if (Tok.is(MMToken::RBrace))
2031  consumeToken();
2032  else {
2033  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2034  Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2035  HadError = true;
2036  }
2037 
2038  // If the active module is a top-level framework, and there are no link
2039  // libraries, automatically link against the framework.
2040  if (ActiveModule->IsFramework && !ActiveModule->isSubFramework() &&
2041  ActiveModule->LinkLibraries.empty()) {
2042  inferFrameworkLink(ActiveModule, Directory, SourceMgr.getFileManager());
2043  }
2044 
2045  // If the module meets all requirements but is still unavailable, mark the
2046  // whole tree as unavailable to prevent it from building.
2047  if (!ActiveModule->IsAvailable && !ActiveModule->IsMissingRequirement &&
2048  ActiveModule->Parent) {
2049  ActiveModule->getTopLevelModule()->markUnavailable();
2050  ActiveModule->getTopLevelModule()->MissingHeaders.append(
2051  ActiveModule->MissingHeaders.begin(), ActiveModule->MissingHeaders.end());
2052  }
2053 
2054  // We're done parsing this module. Pop back to the previous module.
2055  ActiveModule = PreviousActiveModule;
2056 }
2057 
2058 /// Parse an extern module declaration.
2059 ///
2060 /// extern module-declaration:
2061 /// 'extern' 'module' module-id string-literal
2062 void ModuleMapParser::parseExternModuleDecl() {
2063  assert(Tok.is(MMToken::ExternKeyword));
2064  SourceLocation ExternLoc = consumeToken(); // 'extern' keyword
2065 
2066  // Parse 'module' keyword.
2067  if (!Tok.is(MMToken::ModuleKeyword)) {
2068  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
2069  consumeToken();
2070  HadError = true;
2071  return;
2072  }
2073  consumeToken(); // 'module' keyword
2074 
2075  // Parse the module name.
2076  ModuleId Id;
2077  if (parseModuleId(Id)) {
2078  HadError = true;
2079  return;
2080  }
2081 
2082  // Parse the referenced module map file name.
2083  if (!Tok.is(MMToken::StringLiteral)) {
2084  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_mmap_file);
2085  HadError = true;
2086  return;
2087  }
2088  std::string FileName = Tok.getString();
2089  consumeToken(); // filename
2090 
2091  StringRef FileNameRef = FileName;
2092  SmallString<128> ModuleMapFileName;
2093  if (llvm::sys::path::is_relative(FileNameRef)) {
2094  ModuleMapFileName += Directory->getName();
2095  llvm::sys::path::append(ModuleMapFileName, FileName);
2096  FileNameRef = ModuleMapFileName;
2097  }
2098  if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef))
2099  Map.parseModuleMapFile(
2100  File, /*IsSystem=*/false,
2101  Map.HeaderInfo.getHeaderSearchOpts().ModuleMapFileHomeIsCwd
2102  ? Directory
2103  : File->getDir(),
2104  FileID(), nullptr, ExternLoc);
2105 }
2106 
2107 /// Whether to add the requirement \p Feature to the module \p M.
2108 ///
2109 /// This preserves backwards compatibility for two hacks in the Darwin system
2110 /// module map files:
2111 ///
2112 /// 1. The use of 'requires excluded' to make headers non-modular, which
2113 /// should really be mapped to 'textual' now that we have this feature. We
2114 /// drop the 'excluded' requirement, and set \p IsRequiresExcludedHack to
2115 /// true. Later, this bit will be used to map all the headers inside this
2116 /// module to 'textual'.
2117 ///
2118 /// This affects Darwin.C.excluded (for assert.h) and Tcl.Private.
2119 ///
2120 /// 2. Removes a bogus cplusplus requirement from IOKit.avc. This requirement
2121 /// was never correct and causes issues now that we check it, so drop it.
2122 static bool shouldAddRequirement(Module *M, StringRef Feature,
2123  bool &IsRequiresExcludedHack) {
2124  if (Feature == "excluded" &&
2125  (M->fullModuleNameIs({"Darwin", "C", "excluded"}) ||
2126  M->fullModuleNameIs({"Tcl", "Private"}))) {
2127  IsRequiresExcludedHack = true;
2128  return false;
2129  } else if (Feature == "cplusplus" && M->fullModuleNameIs({"IOKit", "avc"})) {
2130  return false;
2131  }
2132 
2133  return true;
2134 }
2135 
2136 /// Parse a requires declaration.
2137 ///
2138 /// requires-declaration:
2139 /// 'requires' feature-list
2140 ///
2141 /// feature-list:
2142 /// feature ',' feature-list
2143 /// feature
2144 ///
2145 /// feature:
2146 /// '!'[opt] identifier
2147 void ModuleMapParser::parseRequiresDecl() {
2148  assert(Tok.is(MMToken::RequiresKeyword));
2149 
2150  // Parse 'requires' keyword.
2151  consumeToken();
2152 
2153  // Parse the feature-list.
2154  do {
2155  bool RequiredState = true;
2156  if (Tok.is(MMToken::Exclaim)) {
2157  RequiredState = false;
2158  consumeToken();
2159  }
2160 
2161  if (!Tok.is(MMToken::Identifier)) {
2162  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
2163  HadError = true;
2164  return;
2165  }
2166 
2167  // Consume the feature name.
2168  std::string Feature = Tok.getString();
2169  consumeToken();
2170 
2171  bool IsRequiresExcludedHack = false;
2172  bool ShouldAddRequirement =
2173  shouldAddRequirement(ActiveModule, Feature, IsRequiresExcludedHack);
2174 
2175  if (IsRequiresExcludedHack)
2176  UsesRequiresExcludedHack.insert(ActiveModule);
2177 
2178  if (ShouldAddRequirement) {
2179  // Add this feature.
2180  ActiveModule->addRequirement(Feature, RequiredState, Map.LangOpts,
2181  *Map.Target);
2182  }
2183 
2184  if (!Tok.is(MMToken::Comma))
2185  break;
2186 
2187  // Consume the comma.
2188  consumeToken();
2189  } while (true);
2190 }
2191 
2192 /// Parse a header declaration.
2193 ///
2194 /// header-declaration:
2195 /// 'textual'[opt] 'header' string-literal
2196 /// 'private' 'textual'[opt] 'header' string-literal
2197 /// 'exclude' 'header' string-literal
2198 /// 'umbrella' 'header' string-literal
2199 ///
2200 /// FIXME: Support 'private textual header'.
2201 void ModuleMapParser::parseHeaderDecl(MMToken::TokenKind LeadingToken,
2202  SourceLocation LeadingLoc) {
2203  // We've already consumed the first token.
2205  if (LeadingToken == MMToken::PrivateKeyword) {
2206  Role = ModuleMap::PrivateHeader;
2207  // 'private' may optionally be followed by 'textual'.
2209  LeadingToken = Tok.Kind;
2210  consumeToken();
2211  }
2212  }
2213 
2214  if (LeadingToken == MMToken::TextualKeyword)
2216 
2217  if (UsesRequiresExcludedHack.count(ActiveModule)) {
2218  // Mark this header 'textual' (see doc comment for
2219  // Module::UsesRequiresExcludedHack).
2221  }
2222 
2223  if (LeadingToken != MMToken::HeaderKeyword) {
2224  if (!Tok.is(MMToken::HeaderKeyword)) {
2225  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2226  << (LeadingToken == MMToken::PrivateKeyword ? "private" :
2227  LeadingToken == MMToken::ExcludeKeyword ? "exclude" :
2228  LeadingToken == MMToken::TextualKeyword ? "textual" : "umbrella");
2229  return;
2230  }
2231  consumeToken();
2232  }
2233 
2234  // Parse the header name.
2235  if (!Tok.is(MMToken::StringLiteral)) {
2236  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2237  << "header";
2238  HadError = true;
2239  return;
2240  }
2242  Header.FileName = Tok.getString();
2243  Header.FileNameLoc = consumeToken();
2244  Header.IsUmbrella = LeadingToken == MMToken::UmbrellaKeyword;
2245  Header.Kind =
2246  (LeadingToken == MMToken::ExcludeKeyword ? Module::HK_Excluded
2247  : Map.headerRoleToKind(Role));
2248 
2249  // Check whether we already have an umbrella.
2250  if (Header.IsUmbrella && ActiveModule->Umbrella) {
2251  Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash)
2252  << ActiveModule->getFullModuleName();
2253  HadError = true;
2254  return;
2255  }
2256 
2257  // If we were given stat information, parse it so we can skip looking for
2258  // the file.
2259  if (Tok.is(MMToken::LBrace)) {
2260  SourceLocation LBraceLoc = consumeToken();
2261 
2262  while (!Tok.is(MMToken::RBrace) && !Tok.is(MMToken::EndOfFile)) {
2263  enum Attribute { Size, ModTime, Unknown };
2264  StringRef Str = Tok.getString();
2265  SourceLocation Loc = consumeToken();
2266  switch (llvm::StringSwitch<Attribute>(Str)
2267  .Case("size", Size)
2268  .Case("mtime", ModTime)
2269  .Default(Unknown)) {
2270  case Size:
2271  if (Header.Size)
2272  Diags.Report(Loc, diag::err_mmap_duplicate_header_attribute) << Str;
2273  if (!Tok.is(MMToken::IntegerLiteral)) {
2274  Diags.Report(Tok.getLocation(),
2275  diag::err_mmap_invalid_header_attribute_value) << Str;
2276  skipUntil(MMToken::RBrace);
2277  break;
2278  }
2279  Header.Size = Tok.getInteger();
2280  consumeToken();
2281  break;
2282 
2283  case ModTime:
2284  if (Header.ModTime)
2285  Diags.Report(Loc, diag::err_mmap_duplicate_header_attribute) << Str;
2286  if (!Tok.is(MMToken::IntegerLiteral)) {
2287  Diags.Report(Tok.getLocation(),
2288  diag::err_mmap_invalid_header_attribute_value) << Str;
2289  skipUntil(MMToken::RBrace);
2290  break;
2291  }
2292  Header.ModTime = Tok.getInteger();
2293  consumeToken();
2294  break;
2295 
2296  case Unknown:
2297  Diags.Report(Loc, diag::err_mmap_expected_header_attribute);
2298  skipUntil(MMToken::RBrace);
2299  break;
2300  }
2301  }
2302 
2303  if (Tok.is(MMToken::RBrace))
2304  consumeToken();
2305  else {
2306  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2307  Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2308  HadError = true;
2309  }
2310  }
2311 
2312  bool NeedsFramework = false;
2313  Map.addUnresolvedHeader(ActiveModule, std::move(Header), NeedsFramework);
2314 
2315  if (NeedsFramework && ActiveModule)
2316  Diags.Report(CurrModuleDeclLoc, diag::note_mmap_add_framework_keyword)
2317  << ActiveModule->getFullModuleName()
2318  << FixItHint::CreateReplacement(CurrModuleDeclLoc, "framework module");
2319 }
2320 
2322  const Module::Header *B) {
2323  return A->NameAsWritten.compare(B->NameAsWritten);
2324 }
2325 
2326 /// Parse an umbrella directory declaration.
2327 ///
2328 /// umbrella-dir-declaration:
2329 /// umbrella string-literal
2330 void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) {
2331  // Parse the directory name.
2332  if (!Tok.is(MMToken::StringLiteral)) {
2333  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
2334  << "umbrella";
2335  HadError = true;
2336  return;
2337  }
2338 
2339  std::string DirName = Tok.getString();
2340  SourceLocation DirNameLoc = consumeToken();
2341 
2342  // Check whether we already have an umbrella.
2343  if (ActiveModule->Umbrella) {
2344  Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash)
2345  << ActiveModule->getFullModuleName();
2346  HadError = true;
2347  return;
2348  }
2349 
2350  // Look for this file.
2351  const DirectoryEntry *Dir = nullptr;
2352  if (llvm::sys::path::is_absolute(DirName))
2353  Dir = SourceMgr.getFileManager().getDirectory(DirName);
2354  else {
2355  SmallString<128> PathName;
2356  PathName = Directory->getName();
2357  llvm::sys::path::append(PathName, DirName);
2358  Dir = SourceMgr.getFileManager().getDirectory(PathName);
2359  }
2360 
2361  if (!Dir) {
2362  Diags.Report(DirNameLoc, diag::warn_mmap_umbrella_dir_not_found)
2363  << DirName;
2364  return;
2365  }
2366 
2367  if (UsesRequiresExcludedHack.count(ActiveModule)) {
2368  // Mark this header 'textual' (see doc comment for
2369  // ModuleMapParser::UsesRequiresExcludedHack). Although iterating over the
2370  // directory is relatively expensive, in practice this only applies to the
2371  // uncommonly used Tcl module on Darwin platforms.
2372  std::error_code EC;
2374  vfs::FileSystem &FS = *SourceMgr.getFileManager().getVirtualFileSystem();
2375  for (vfs::recursive_directory_iterator I(FS, Dir->getName(), EC), E;
2376  I != E && !EC; I.increment(EC)) {
2377  if (const FileEntry *FE =
2378  SourceMgr.getFileManager().getFile(I->getName())) {
2379 
2380  Module::Header Header = {I->getName(), FE};
2381  Headers.push_back(std::move(Header));
2382  }
2383  }
2384 
2385  // Sort header paths so that the pcm doesn't depend on iteration order.
2386  llvm::array_pod_sort(Headers.begin(), Headers.end(), compareModuleHeaders);
2387 
2388  for (auto &Header : Headers)
2389  Map.addHeader(ActiveModule, std::move(Header), ModuleMap::TextualHeader);
2390  return;
2391  }
2392 
2393  if (Module *OwningModule = Map.UmbrellaDirs[Dir]) {
2394  Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
2395  << OwningModule->getFullModuleName();
2396  HadError = true;
2397  return;
2398  }
2399 
2400  // Record this umbrella directory.
2401  Map.setUmbrellaDir(ActiveModule, Dir, DirName);
2402 }
2403 
2404 /// Parse a module export declaration.
2405 ///
2406 /// export-declaration:
2407 /// 'export' wildcard-module-id
2408 ///
2409 /// wildcard-module-id:
2410 /// identifier
2411 /// '*'
2412 /// identifier '.' wildcard-module-id
2413 void ModuleMapParser::parseExportDecl() {
2414  assert(Tok.is(MMToken::ExportKeyword));
2415  SourceLocation ExportLoc = consumeToken();
2416 
2417  // Parse the module-id with an optional wildcard at the end.
2418  ModuleId ParsedModuleId;
2419  bool Wildcard = false;
2420  do {
2421  // FIXME: Support string-literal module names here.
2422  if (Tok.is(MMToken::Identifier)) {
2423  ParsedModuleId.push_back(std::make_pair(Tok.getString(),
2424  Tok.getLocation()));
2425  consumeToken();
2426 
2427  if (Tok.is(MMToken::Period)) {
2428  consumeToken();
2429  continue;
2430  }
2431 
2432  break;
2433  }
2434 
2435  if(Tok.is(MMToken::Star)) {
2436  Wildcard = true;
2437  consumeToken();
2438  break;
2439  }
2440 
2441  Diags.Report(Tok.getLocation(), diag::err_mmap_module_id);
2442  HadError = true;
2443  return;
2444  } while (true);
2445 
2446  Module::UnresolvedExportDecl Unresolved = {
2447  ExportLoc, ParsedModuleId, Wildcard
2448  };
2449  ActiveModule->UnresolvedExports.push_back(Unresolved);
2450 }
2451 
2452 /// Parse a module export_as declaration.
2453 ///
2454 /// export-as-declaration:
2455 /// 'export_as' identifier
2456 void ModuleMapParser::parseExportAsDecl() {
2457  assert(Tok.is(MMToken::ExportAsKeyword));
2458  consumeToken();
2459 
2460  if (!Tok.is(MMToken::Identifier)) {
2461  Diags.Report(Tok.getLocation(), diag::err_mmap_module_id);
2462  HadError = true;
2463  return;
2464  }
2465 
2466  if (ActiveModule->Parent) {
2467  Diags.Report(Tok.getLocation(), diag::err_mmap_submodule_export_as);
2468  consumeToken();
2469  return;
2470  }
2471 
2472  if (!ActiveModule->ExportAsModule.empty()) {
2473  if (ActiveModule->ExportAsModule == Tok.getString()) {
2474  Diags.Report(Tok.getLocation(), diag::warn_mmap_redundant_export_as)
2475  << ActiveModule->Name << Tok.getString();
2476  } else {
2477  Diags.Report(Tok.getLocation(), diag::err_mmap_conflicting_export_as)
2478  << ActiveModule->Name << ActiveModule->ExportAsModule
2479  << Tok.getString();
2480  }
2481  }
2482 
2483  ActiveModule->ExportAsModule = Tok.getString();
2484  Map.addLinkAsDependency(ActiveModule);
2485 
2486  consumeToken();
2487 }
2488 
2489 /// Parse a module use declaration.
2490 ///
2491 /// use-declaration:
2492 /// 'use' wildcard-module-id
2493 void ModuleMapParser::parseUseDecl() {
2494  assert(Tok.is(MMToken::UseKeyword));
2495  auto KWLoc = consumeToken();
2496  // Parse the module-id.
2497  ModuleId ParsedModuleId;
2498  parseModuleId(ParsedModuleId);
2499 
2500  if (ActiveModule->Parent)
2501  Diags.Report(KWLoc, diag::err_mmap_use_decl_submodule);
2502  else
2503  ActiveModule->UnresolvedDirectUses.push_back(ParsedModuleId);
2504 }
2505 
2506 /// Parse a link declaration.
2507 ///
2508 /// module-declaration:
2509 /// 'link' 'framework'[opt] string-literal
2510 void ModuleMapParser::parseLinkDecl() {
2511  assert(Tok.is(MMToken::LinkKeyword));
2512  SourceLocation LinkLoc = consumeToken();
2513 
2514  // Parse the optional 'framework' keyword.
2515  bool IsFramework = false;
2517  consumeToken();
2518  IsFramework = true;
2519  }
2520 
2521  // Parse the library name
2522  if (!Tok.is(MMToken::StringLiteral)) {
2523  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_library_name)
2524  << IsFramework << SourceRange(LinkLoc);
2525  HadError = true;
2526  return;
2527  }
2528 
2529  std::string LibraryName = Tok.getString();
2530  consumeToken();
2531  ActiveModule->LinkLibraries.push_back(Module::LinkLibrary(LibraryName,
2532  IsFramework));
2533 }
2534 
2535 /// Parse a configuration macro declaration.
2536 ///
2537 /// module-declaration:
2538 /// 'config_macros' attributes[opt] config-macro-list?
2539 ///
2540 /// config-macro-list:
2541 /// identifier (',' identifier)?
2542 void ModuleMapParser::parseConfigMacros() {
2543  assert(Tok.is(MMToken::ConfigMacros));
2544  SourceLocation ConfigMacrosLoc = consumeToken();
2545 
2546  // Only top-level modules can have configuration macros.
2547  if (ActiveModule->Parent) {
2548  Diags.Report(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule);
2549  }
2550 
2551  // Parse the optional attributes.
2552  Attributes Attrs;
2553  if (parseOptionalAttributes(Attrs))
2554  return;
2555 
2556  if (Attrs.IsExhaustive && !ActiveModule->Parent) {
2557  ActiveModule->ConfigMacrosExhaustive = true;
2558  }
2559 
2560  // If we don't have an identifier, we're done.
2561  // FIXME: Support macros with the same name as a keyword here.
2562  if (!Tok.is(MMToken::Identifier))
2563  return;
2564 
2565  // Consume the first identifier.
2566  if (!ActiveModule->Parent) {
2567  ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2568  }
2569  consumeToken();
2570 
2571  do {
2572  // If there's a comma, consume it.
2573  if (!Tok.is(MMToken::Comma))
2574  break;
2575  consumeToken();
2576 
2577  // We expect to see a macro name here.
2578  // FIXME: Support macros with the same name as a keyword here.
2579  if (!Tok.is(MMToken::Identifier)) {
2580  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_config_macro);
2581  break;
2582  }
2583 
2584  // Consume the macro name.
2585  if (!ActiveModule->Parent) {
2586  ActiveModule->ConfigMacros.push_back(Tok.getString().str());
2587  }
2588  consumeToken();
2589  } while (true);
2590 }
2591 
2592 /// Format a module-id into a string.
2593 static std::string formatModuleId(const ModuleId &Id) {
2594  std::string result;
2595  {
2596  llvm::raw_string_ostream OS(result);
2597 
2598  for (unsigned I = 0, N = Id.size(); I != N; ++I) {
2599  if (I)
2600  OS << ".";
2601  OS << Id[I].first;
2602  }
2603  }
2604 
2605  return result;
2606 }
2607 
2608 /// Parse a conflict declaration.
2609 ///
2610 /// module-declaration:
2611 /// 'conflict' module-id ',' string-literal
2612 void ModuleMapParser::parseConflict() {
2613  assert(Tok.is(MMToken::Conflict));
2614  SourceLocation ConflictLoc = consumeToken();
2615  Module::UnresolvedConflict Conflict;
2616 
2617  // Parse the module-id.
2618  if (parseModuleId(Conflict.Id))
2619  return;
2620 
2621  // Parse the ','.
2622  if (!Tok.is(MMToken::Comma)) {
2623  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_comma)
2624  << SourceRange(ConflictLoc);
2625  return;
2626  }
2627  consumeToken();
2628 
2629  // Parse the message.
2630  if (!Tok.is(MMToken::StringLiteral)) {
2631  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_message)
2632  << formatModuleId(Conflict.Id);
2633  return;
2634  }
2635  Conflict.Message = Tok.getString().str();
2636  consumeToken();
2637 
2638  // Add this unresolved conflict.
2639  ActiveModule->UnresolvedConflicts.push_back(Conflict);
2640 }
2641 
2642 /// Parse an inferred module declaration (wildcard modules).
2643 ///
2644 /// module-declaration:
2645 /// 'explicit'[opt] 'framework'[opt] 'module' * attributes[opt]
2646 /// { inferred-module-member* }
2647 ///
2648 /// inferred-module-member:
2649 /// 'export' '*'
2650 /// 'exclude' identifier
2651 void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) {
2652  assert(Tok.is(MMToken::Star));
2653  SourceLocation StarLoc = consumeToken();
2654  bool Failed = false;
2655 
2656  // Inferred modules must be submodules.
2657  if (!ActiveModule && !Framework) {
2658  Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule);
2659  Failed = true;
2660  }
2661 
2662  if (ActiveModule) {
2663  // Inferred modules must have umbrella directories.
2664  if (!Failed && ActiveModule->IsAvailable &&
2665  !ActiveModule->getUmbrellaDir()) {
2666  Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella);
2667  Failed = true;
2668  }
2669 
2670  // Check for redefinition of an inferred module.
2671  if (!Failed && ActiveModule->InferSubmodules) {
2672  Diags.Report(StarLoc, diag::err_mmap_inferred_redef);
2673  if (ActiveModule->InferredSubmoduleLoc.isValid())
2674  Diags.Report(ActiveModule->InferredSubmoduleLoc,
2675  diag::note_mmap_prev_definition);
2676  Failed = true;
2677  }
2678 
2679  // Check for the 'framework' keyword, which is not permitted here.
2680  if (Framework) {
2681  Diags.Report(StarLoc, diag::err_mmap_inferred_framework_submodule);
2682  Framework = false;
2683  }
2684  } else if (Explicit) {
2685  Diags.Report(StarLoc, diag::err_mmap_explicit_inferred_framework);
2686  Explicit = false;
2687  }
2688 
2689  // If there were any problems with this inferred submodule, skip its body.
2690  if (Failed) {
2691  if (Tok.is(MMToken::LBrace)) {
2692  consumeToken();
2693  skipUntil(MMToken::RBrace);
2694  if (Tok.is(MMToken::RBrace))
2695  consumeToken();
2696  }
2697  HadError = true;
2698  return;
2699  }
2700 
2701  // Parse optional attributes.
2702  Attributes Attrs;
2703  if (parseOptionalAttributes(Attrs))
2704  return;
2705 
2706  if (ActiveModule) {
2707  // Note that we have an inferred submodule.
2708  ActiveModule->InferSubmodules = true;
2709  ActiveModule->InferredSubmoduleLoc = StarLoc;
2710  ActiveModule->InferExplicitSubmodules = Explicit;
2711  } else {
2712  // We'll be inferring framework modules for this directory.
2713  Map.InferredDirectories[Directory].InferModules = true;
2714  Map.InferredDirectories[Directory].Attrs = Attrs;
2715  Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile;
2716  // FIXME: Handle the 'framework' keyword.
2717  }
2718 
2719  // Parse the opening brace.
2720  if (!Tok.is(MMToken::LBrace)) {
2721  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard);
2722  HadError = true;
2723  return;
2724  }
2725  SourceLocation LBraceLoc = consumeToken();
2726 
2727  // Parse the body of the inferred submodule.
2728  bool Done = false;
2729  do {
2730  switch (Tok.Kind) {
2731  case MMToken::EndOfFile:
2732  case MMToken::RBrace:
2733  Done = true;
2734  break;
2735 
2737  if (ActiveModule) {
2738  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2739  << (ActiveModule != nullptr);
2740  consumeToken();
2741  break;
2742  }
2743 
2744  consumeToken();
2745  // FIXME: Support string-literal module names here.
2746  if (!Tok.is(MMToken::Identifier)) {
2747  Diags.Report(Tok.getLocation(), diag::err_mmap_missing_exclude_name);
2748  break;
2749  }
2750 
2751  Map.InferredDirectories[Directory].ExcludedModules
2752  .push_back(Tok.getString());
2753  consumeToken();
2754  break;
2755 
2757  if (!ActiveModule) {
2758  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2759  << (ActiveModule != nullptr);
2760  consumeToken();
2761  break;
2762  }
2763 
2764  consumeToken();
2765  if (Tok.is(MMToken::Star))
2766  ActiveModule->InferExportWildcard = true;
2767  else
2768  Diags.Report(Tok.getLocation(),
2769  diag::err_mmap_expected_export_wildcard);
2770  consumeToken();
2771  break;
2772 
2778  default:
2779  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
2780  << (ActiveModule != nullptr);
2781  consumeToken();
2782  break;
2783  }
2784  } while (!Done);
2785 
2786  if (Tok.is(MMToken::RBrace))
2787  consumeToken();
2788  else {
2789  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
2790  Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
2791  HadError = true;
2792  }
2793 }
2794 
2795 /// Parse optional attributes.
2796 ///
2797 /// attributes:
2798 /// attribute attributes
2799 /// attribute
2800 ///
2801 /// attribute:
2802 /// [ identifier ]
2803 ///
2804 /// \param Attrs Will be filled in with the parsed attributes.
2805 ///
2806 /// \returns true if an error occurred, false otherwise.
2807 bool ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) {
2808  bool HadError = false;
2809 
2810  while (Tok.is(MMToken::LSquare)) {
2811  // Consume the '['.
2812  SourceLocation LSquareLoc = consumeToken();
2813 
2814  // Check whether we have an attribute name here.
2815  if (!Tok.is(MMToken::Identifier)) {
2816  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute);
2817  skipUntil(MMToken::RSquare);
2818  if (Tok.is(MMToken::RSquare))
2819  consumeToken();
2820  HadError = true;
2821  }
2822 
2823  // Decode the attribute name.
2824  AttributeKind Attribute
2825  = llvm::StringSwitch<AttributeKind>(Tok.getString())
2826  .Case("exhaustive", AT_exhaustive)
2827  .Case("extern_c", AT_extern_c)
2828  .Case("no_undeclared_includes", AT_no_undeclared_includes)
2829  .Case("system", AT_system)
2830  .Default(AT_unknown);
2831  switch (Attribute) {
2832  case AT_unknown:
2833  Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute)
2834  << Tok.getString();
2835  break;
2836 
2837  case AT_system:
2838  Attrs.IsSystem = true;
2839  break;
2840 
2841  case AT_extern_c:
2842  Attrs.IsExternC = true;
2843  break;
2844 
2845  case AT_exhaustive:
2846  Attrs.IsExhaustive = true;
2847  break;
2848 
2849  case AT_no_undeclared_includes:
2850  Attrs.NoUndeclaredIncludes = true;
2851  break;
2852  }
2853  consumeToken();
2854 
2855  // Consume the ']'.
2856  if (!Tok.is(MMToken::RSquare)) {
2857  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare);
2858  Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match);
2859  skipUntil(MMToken::RSquare);
2860  HadError = true;
2861  }
2862 
2863  if (Tok.is(MMToken::RSquare))
2864  consumeToken();
2865  }
2866 
2867  return HadError;
2868 }
2869 
2870 /// Parse a module map file.
2871 ///
2872 /// module-map-file:
2873 /// module-declaration*
2875  do {
2876  switch (Tok.Kind) {
2877  case MMToken::EndOfFile:
2878  return HadError;
2879 
2884  parseModuleDecl();
2885  break;
2886 
2887  case MMToken::Comma:
2888  case MMToken::ConfigMacros:
2889  case MMToken::Conflict:
2890  case MMToken::Exclaim:
2895  case MMToken::Identifier:
2896  case MMToken::LBrace:
2897  case MMToken::LinkKeyword:
2898  case MMToken::LSquare:
2899  case MMToken::Period:
2901  case MMToken::RBrace:
2902  case MMToken::RSquare:
2904  case MMToken::Star:
2909  case MMToken::UseKeyword:
2910  Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
2911  HadError = true;
2912  consumeToken();
2913  break;
2914  }
2915  } while (true);
2916 }
2917 
2918 bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem,
2919  const DirectoryEntry *Dir, FileID ID,
2920  unsigned *Offset,
2921  SourceLocation ExternModuleLoc) {
2922  assert(Target && "Missing target information");
2923  llvm::DenseMap<const FileEntry *, bool>::iterator Known
2924  = ParsedModuleMap.find(File);
2925  if (Known != ParsedModuleMap.end())
2926  return Known->second;
2927 
2928  // If the module map file wasn't already entered, do so now.
2929  if (ID.isInvalid()) {
2930  auto FileCharacter =
2932  ID = SourceMgr.createFileID(File, ExternModuleLoc, FileCharacter);
2933  }
2934 
2935  assert(Target && "Missing target information");
2936  const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(ID);
2937  if (!Buffer)
2938  return ParsedModuleMap[File] = true;
2939  assert((!Offset || *Offset <= Buffer->getBufferSize()) &&
2940  "invalid buffer offset");
2941 
2942  // Parse this module map file.
2943  Lexer L(SourceMgr.getLocForStartOfFile(ID), MMapLangOpts,
2944  Buffer->getBufferStart(),
2945  Buffer->getBufferStart() + (Offset ? *Offset : 0),
2946  Buffer->getBufferEnd());
2947  SourceLocation Start = L.getSourceLocation();
2948  ModuleMapParser Parser(L, SourceMgr, Target, Diags, *this, File, Dir,
2949  IsSystem);
2950  bool Result = Parser.parseModuleMapFile();
2951  ParsedModuleMap[File] = Result;
2952 
2953  if (Offset) {
2954  auto Loc = SourceMgr.getDecomposedLoc(Parser.getLocation());
2955  assert(Loc.first == ID && "stopped in a different file?");
2956  *Offset = Loc.second;
2957  }
2958 
2959  // Notify callbacks that we parsed it.
2960  for (const auto &Cb : Callbacks)
2961  Cb->moduleMapFileRead(Start, *File, IsSystem);
2962 
2963  return Result;
2964 }
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:213
ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags, const LangOptions &LangOpts, const TargetInfo *Target, HeaderSearch &HeaderInfo)
Construct a new module map.
Definition: ModuleMap.cpp:312
ModuleHeaderRole getRole() const
The role of this header within the module.
Definition: ModuleMap.h:167
static unsigned getSpelling(const Token &Tok, const char *&Buffer, const SourceManager &SourceMgr, const LangOptions &LangOpts, bool *Invalid=nullptr)
getSpelling - This method is used to get the spelling of a token into a preallocated buffer...
Definition: Lexer.cpp:389
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:309
SourceLocation getLocation() const
Definition: ModuleMap.cpp:1322
std::string Name
The name of this module.
Definition: Module.h:68
static Module * getTopLevelOrNull(Module *M)
Definition: ModuleMap.cpp:460
This header is included but private.
Definition: ModuleMap.h:127
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:77
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
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:188
std::string Message
The message provided to the user when there is a conflict.
Definition: Module.h:352
bool isSubFramework() const
Determine whether this module is a subframework of another framework.
Definition: Module.h:424
unsigned ImplicitModuleMaps
Implicit module maps.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
void dump()
Dump the contents of the module map, for debugging purposes.
Definition: ModuleMap.cpp:1201
Defines the clang::FileManager interface and associated types.
An unresolved conflict with another module.
Definition: Module.h:347
time_t getModificationTime() const
Definition: FileManager.h:91
This header is part of the module (for layering purposes) but should be textually included...
Definition: ModuleMap.h:131
uint64_t IntegerValue
Definition: ModuleMap.cpp:1310
unsigned IsExternC
Whether this is an &#39;extern "C"&#39; module (which implicitly puts all headers in it within an &#39;extern "C"...
Definition: Module.h:231
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:95
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:357
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:451
Defines the SourceManager interface.
void loadTopLevelSystemModules()
Load all known, top-level system modules.
Defines the clang::Module class, which describes a module in the source code.
void excludeHeader(Module *Mod, Module::Header Header)
Marks this header as being excluded from the given module.
Definition: ModuleMap.cpp:1169
unsigned IsFramework
Whether this is a framework module.
Definition: Module.h:219
const FileEntry * getModuleMapFileForUniquing(const Module *M) const
Get the module map file that (along with the module name) uniquely identifies this module...
Definition: ModuleMap.cpp:1188
ModuleMapParser(Lexer &L, SourceManager &SourceMgr, const TargetInfo *Target, DiagnosticsEngine &Diags, ModuleMap &Map, const FileEntry *ModuleMapFile, const DirectoryEntry *Directory, bool IsSystem)
Definition: ModuleMap.cpp:1418
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
bool isCompilingModule() const
Are we compiling a module interface (.cppm or module map)?
Definition: LangOptions.h:227
Parser - This implements a parser for the C family of languages.
Definition: Parser.h:57
bool resolveUses(Module *Mod, bool Complain)
Resolve all of the unresolved uses in the given module.
Definition: ModuleMap.cpp:1236
void MarkFileModuleHeader(const FileEntry *File, ModuleMap::ModuleHeaderRole Role, bool IsCompiledModuleHeader)
Mark the specified file as part of a module.
unsigned Location
Definition: ModuleMap.cpp:1303
const char * StringData
Definition: ModuleMap.cpp:1307
const FileEntry * lookupModuleMapFile(const DirectoryEntry *Dir, bool IsFramework)
Try to find a module map file in the given directory, returning nullptr if none is found...
virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC)=0
Get a directory_iterator for Dir.
Module * lookupModuleQualified(StringRef Name, Module *Context) const
Retrieve a module with the given name within the given context, using direct (qualified) name lookup...
Definition: ModuleMap.cpp:781
Module * createShadowedModule(StringRef Name, bool IsFramework, Module *ShadowingModule)
Create a new top-level module that is shadowed by ShadowingModule.
Definition: ModuleMap.cpp:1045
static void appendSubframeworkPaths(Module *Mod, SmallVectorImpl< char > &Path)
Append to Paths the set of paths needed to get to the subframework in which the given module lives...
Definition: ModuleMap.cpp:156
bool isPartOfFramework() const
Determine whether this module is a part of a framework, either because it is a framework module or be...
Definition: Module.h:414
tok::TokenKind getKind() const
Definition: Token.h:90
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
void markUnavailable(bool MissingRequirement=false)
Mark this module and all of its submodules as unavailable.
Definition: Module.cpp:257
The virtual file system interface.
unsigned GetStringLength() const
FileManager & getFileManager() const
A library or framework to link against when an entity from this module is used.
Definition: Module.h:319
bool resolveConflicts(Module *Mod, bool Complain)
Resolve all of the unresolved conflicts in the given module.
Definition: ModuleMap.cpp:1249
void resolveHeaderDirectives(const FileEntry *File) const
Resolve all lazy header directives for the specified file.
Definition: ModuleMap.cpp:1115
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
bool isHeaderUnavailableInModule(const FileEntry *Header, const Module *RequestingModule) const
Determine whether the given header is unavailable as part of the specified module.
Definition: ModuleMap.cpp:671
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
void setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir, Twine NameAsWritten)
Sets the umbrella directory of the given module to the given directory.
Definition: ModuleMap.cpp:1072
An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
Compiling a module from a module map.
Definition: LangOptions.h:74
Describes a module or submodule.
Definition: Module.h:65
bool isAccessibleFrom(Module *M) const
Whether this header is accessible from the specified module.
Definition: ModuleMap.h:175
static ModuleHeaderRole headerKindToRole(Module::HeaderKind Kind)
Convert a header kind to a role. Requires Kind to not be HK_Excluded.
Definition: ModuleMap.cpp:90
bool isInvalid() const
Module * findModule(StringRef Name) const
Retrieve a module with the given name.
Definition: ModuleMap.cpp:763
Module * createGlobalModuleForInterfaceUnit(SourceLocation Loc)
Create a &#39;global module&#39; for a C++ Modules TS module interface unit.
Definition: ModuleMap.cpp:808
static bool isBuiltinHeader(StringRef FileName)
Is this a compiler builtin header?
Definition: ModuleMap.cpp:373
directory_iterator & increment(std::error_code &EC)
Equivalent to operator++, with an error code.
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e...
Definition: Module.h:248
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:182
bool hasUDSuffix() const
Return true if this token is a string or character literal which has a ud-suffix. ...
Definition: Token.h:291
uint32_t Offset
Definition: CacheTokens.cpp:43
const FormatToken & Tok
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
std::string Message
The message provided to the user when there is a conflict.
Definition: Module.h:365
ModuleId Id
The (unresolved) module id.
Definition: Module.h:349
unsigned StringLength
Definition: ModuleMap.cpp:1304
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
bool isSubModuleOf(const Module *Other) const
Determine whether this module is a submodule of the given other module.
Definition: Module.cpp:132
Module * Parent
The parent of this module.
Definition: Module.h:91
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Module.h:234
Defines the Diagnostic-related interfaces.
void setTarget(const TargetInfo &Target)
Set the target information.
Definition: ModuleMap.cpp:327
unsigned NoUndeclaredIncludes
Whether files in this module can only include non-modular headers and headers from used modules...
Definition: Module.h:259
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:148
StringRef getString() const
Definition: ModuleMap.cpp:1330
const FileEntry * getContainingModuleMapFile(const Module *Module) const
Retrieve the module map file containing the definition of the given module.
Definition: ModuleMap.cpp:1180
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:226
NodeId Parent
Definition: ASTDiff.cpp:192
Module * createModuleForInterfaceUnit(SourceLocation Loc, StringRef Name, Module *GlobalModule)
Create a new module for a C++ Modules TS module interface unit.
Definition: ModuleMap.cpp:817
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
static bool violatesPrivateInclude(Module *RequestingModule, const FileEntry *IncFileEnt, ModuleMap::KnownHeader Header)
Definition: ModuleMap.cpp:437
void setParent(Module *M)
Set the parent of this module.
Definition: Module.h:430
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:191
const DirectoryEntry * getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
bool parseModuleMapFile(const FileEntry *File, bool IsSystem, const DirectoryEntry *HomeDir, FileID ID=FileID(), unsigned *Offset=nullptr, SourceLocation ExternModuleLoc=SourceLocation())
Parse the given module map file, and record any modules we encounter.
Definition: ModuleMap.cpp:2918
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:285
ModuleHeaderRole
Flags describing the role of a module header.
Definition: ModuleMap.h:122
StringRef Filename
Definition: Format.cpp:1605
SmallVector< std::pair< std::string, SourceLocation >, 2 > ModuleId
Describes the name of a module.
Definition: Module.h:52
Exposes information about the current target.
Definition: TargetInfo.h:54
void diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, const FileEntry *File)
Reports errors if a module must not include a specific file.
Definition: ModuleMap.cpp:464
Defines the clang::LangOptions interface.
SmallVector< ModuleId, 2 > UnresolvedDirectUses
The set of use declarations that have yet to be resolved.
Definition: Module.h:315
int Id
Definition: ASTDiff.cpp:191
ModuleId Id
The name of the module.
Definition: Module.h:300
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:255
bool UseExportAsModuleLinkName
Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...
Definition: Module.h:340
void print(raw_ostream &OS, unsigned Indent=0) const
Print the module map for this module to the given stream.
Definition: Module.cpp:373
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
bool resolveExports(Module *Mod, bool Complain)
Resolve all of the unresolved exports in the given module.
Definition: ModuleMap.cpp:1223
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:336
static int compareModuleHeaders(const Module::Header *A, const Module::Header *B)
Definition: ModuleMap.cpp:2321
HeaderSearchOptions & getHeaderSearchOpts() const
Retrieve the header-search options with which this header search was initialized. ...
Definition: HeaderSearch.h:271
static bool isBetterKnownHeader(const ModuleMap::KnownHeader &New, const ModuleMap::KnownHeader &Old)
Definition: ModuleMap.cpp:540
KnownHeader findModuleForHeader(const FileEntry *File, bool AllowTextual=false)
Retrieve the module that owns the given header file, if any.
Definition: ModuleMap.cpp:560
void setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader, Twine NameAsWritten)
Sets the umbrella header of the given module to the given header.
Definition: ModuleMap.cpp:1060
static std::string formatModuleId(const ModuleId &Id)
Format a module-id into a string.
Definition: ModuleMap.cpp:2593
std::string NameAsWritten
Definition: Module.h:152
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Module.h:379
Information about a header directive as found in the module map file.
Definition: Module.h:151
The result type of a method or function.
StringRef GetString() const
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:291
const DirectoryEntry * Directory
The build directory of this module.
Definition: Module.h:96
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileManager.h:94
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.
Definition: ModuleMap.cpp:788
static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir, FileManager &FileMgr)
For a framework module, infer the framework against which we should link.
Definition: ModuleMap.cpp:846
bool fullModuleNameIs(ArrayRef< StringRef > nameParts) const
Whether the full name of this module is equal to joining nameParts with "."s.
Definition: Module.cpp:198
SourceLocation getLocation()
Definition: ModuleMap.cpp:1432
Kind
static bool shouldAddRequirement(Module *M, StringRef Feature, bool &IsRequiresExcludedHack)
Whether to add the requirement Feature to the module M.
Definition: ModuleMap.cpp:2122
LLVM_READONLY bool isValidIdentifier(StringRef S, bool AllowDollar=false)
Return true if this is a valid ASCII identifier.
Definition: CharInfo.h:185
static StringRef sanitizeFilenameAsIdentifier(StringRef Name, SmallVectorImpl< char > &Buffer)
"Sanitize" a filename so that it can be used as an identifier.
Definition: ModuleMap.cpp:334
Encodes a location in the source.
StringRef getName() const
Definition: FileManager.h:84
bool is(tok::TokenKind Kind) const
Definition: FormatToken.h:310
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed, for use in "private" modules.
Definition: Module.h:113
bool is(TokenKind K) const
Definition: ModuleMap.cpp:1320
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Module.h:168
const FileEntry * Entry
Definition: Module.h:153
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:266
This is a fragment of the global module within some C++ Modules TS module.
Definition: Module.h:83
Module * lookupModuleUnqualified(StringRef Name, Module *Context) const
Retrieve a module with the given name using lexical name lookup, starting at the given context...
Definition: ModuleMap.cpp:771
bool Wildcard
Whether this export declaration ends in a wildcard, indicating that all of its submodules should be e...
Definition: Module.h:305
static Module::HeaderKind headerRoleToKind(ModuleHeaderRole Role)
Convert a header role to a kind.
Definition: ModuleMap.cpp:75
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
This header is normally included in the module.
Definition: ModuleMap.h:124
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Definition: ModuleMap.cpp:1140
bool parseModuleMapFile()
Parse a module map file.
Definition: ModuleMap.cpp:2874
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
StringRef getCanonicalName(const DirectoryEntry *Dir)
Retrieve the canonical name for a given directory.
A conflict between two modules.
Definition: Module.h:360
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:184
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Module.h:172
llvm::PointerUnion< const DirectoryEntry *, const FileEntry * > Umbrella
The umbrella header or directory.
Definition: Module.h:103
Module * ShadowingModule
A module with the same name that shadows this module.
Definition: Module.h:201
off_t getSize() const
Definition: FileManager.h:87
ArrayRef< KnownHeader > findAllModulesForHeader(const FileEntry *File) const
Retrieve all the modules that contain the given header file.
Definition: ModuleMap.cpp:658
FileID getMainFileID() const
Returns the FileID of the main source file.
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Definition: Module.h:288
LLVM_READONLY bool isIdentifierBody(unsigned char c, bool AllowDollar=false)
Returns true if this is a body character of a C identifier, which is [a-zA-Z0-9_].
Definition: CharInfo.h:59
Defines the virtual file system interface vfs::FileSystem.
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Module.h:496
unsigned getLength() const
Definition: Token.h:127
SourceLocation DefinitionLoc
The location of the module definition.
Definition: Module.h:71
LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:94
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
uint64_t getInteger() const
Definition: ModuleMap.cpp:1326
void addLinkAsDependency(Module *Mod)
Make module to use export_as as the link dependency name if enough information is available or add it...
Definition: ModuleMap.cpp:68
A token in a module map file.
Definition: ModuleMap.cpp:1271
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:369
SmallVector< Module *, 2 > DirectUses
The directly used modules.
Definition: Module.h:312
Describes an exported module that has not yet been resolved (perhaps because the module it refers to ...
Definition: Module.h:295
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:207
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator.
Defines the clang::SourceLocation class and associated facilities.
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:240
StringRef getRawIdentifier() const
getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode), returns a reference to the text substring in the buffer if known.
Definition: Token.h:203
Module * getModule() const
Retrieve the module the header is stored in.
Definition: ModuleMap.h:164
IntrusiveRefCntPtr< vfs::FileSystem > getVirtualFileSystem() const
Definition: FileManager.h:225
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
bool directlyUses(const Module *Requested) const
Determine whether this module has declared its intention to directly use another module.
Definition: Module.cpp:227
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
Definition: ModuleMap.cpp:57
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1633
Defines the clang::TargetInfo interface.
~ModuleMap()
Destroy the module map.
Definition: ModuleMap.cpp:320
bool isHeaderInUnavailableModule(const FileEntry *Header) const
Determine whether the given header is part of a module marked &#39;unavailable&#39;.
Definition: ModuleMap.cpp:666
AttributeKind
Enumerates the known attributes.
Definition: ModuleMap.cpp:1659
std::string UmbrellaAsWritten
The name of the umbrella entry, as written in the module map.
Definition: Module.h:109
Module * Other
The module that this module conflicts with.
Definition: Module.h:362
A trivial tuple used to represent a source range.
A header that is known to reside within a given module, whether it was included or excluded...
Definition: ModuleMap.h:149
void setInferredModuleAllowedBy(Module *M, const FileEntry *ModuleMap)
Definition: ModuleMap.cpp:1196
This class handles loading and caching of source files into memory.
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:244
This is a C++ Modules TS module interface unit.
Definition: Module.h:79
StringRef getName() const
Definition: FileManager.h:51