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