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