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