xref: /freebsd/contrib/llvm-project/clang/lib/Basic/Module.cpp (revision d9a42747950146bf03cda7f6e25d219253f8a57a) 
1 //===- Module.cpp - Describe a module -------------------------------------===//
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 Module class, which describes a module in the source
10 // code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/Module.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Basic/LangOptions.h"
18 #include "clang/Basic/SourceLocation.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/Support/Compiler.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <algorithm>
29 #include <cassert>
30 #include <functional>
31 #include <string>
32 #include <utility>
33 #include <vector>
34 
35 using namespace clang;
36 
37 Module::Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent,
38                bool IsFramework, bool IsExplicit, unsigned VisibilityID)
39     : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent),
40       VisibilityID(VisibilityID), IsUnimportable(false),
41       HasIncompatibleModuleFile(false), IsAvailable(true),
42       IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(IsExplicit),
43       IsSystem(false), IsExternC(false), IsInferred(false),
44       InferSubmodules(false), InferExplicitSubmodules(false),
45       InferExportWildcard(false), ConfigMacrosExhaustive(false),
46       NoUndeclaredIncludes(false), ModuleMapIsPrivate(false),
47       NameVisibility(Hidden) {
48   if (Parent) {
49     IsAvailable = Parent->isAvailable();
50     IsUnimportable = Parent->isUnimportable();
51     IsSystem = Parent->IsSystem;
52     IsExternC = Parent->IsExternC;
53     NoUndeclaredIncludes = Parent->NoUndeclaredIncludes;
54     ModuleMapIsPrivate = Parent->ModuleMapIsPrivate;
55 
56     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
57     Parent->SubModules.push_back(this);
58   }
59 }
60 
61 Module::~Module() {
62   for (submodule_iterator I = submodule_begin(), IEnd = submodule_end();
63        I != IEnd; ++I) {
64     delete *I;
65   }
66 }
67 
68 static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature) {
69   StringRef Platform = Target.getPlatformName();
70   StringRef Env = Target.getTriple().getEnvironmentName();
71 
72   // Attempt to match platform and environment.
73   if (Platform == Feature || Target.getTriple().getOSName() == Feature ||
74       Env == Feature)
75     return true;
76 
77   auto CmpPlatformEnv = [](StringRef LHS, StringRef RHS) {
78     auto Pos = LHS.find('-');
79     if (Pos == StringRef::npos)
80       return false;
81     SmallString<128> NewLHS = LHS.slice(0, Pos);
82     NewLHS += LHS.slice(Pos+1, LHS.size());
83     return NewLHS == RHS;
84   };
85 
86   SmallString<128> PlatformEnv = Target.getTriple().getOSAndEnvironmentName();
87   // Darwin has different but equivalent variants for simulators, example:
88   //   1. x86_64-apple-ios-simulator
89   //   2. x86_64-apple-iossimulator
90   // where both are valid examples of the same platform+environment but in the
91   // variant (2) the simulator is hardcoded as part of the platform name. Both
92   // forms above should match for "iossimulator" requirement.
93   if (Target.getTriple().isOSDarwin() && PlatformEnv.endswith("simulator"))
94     return PlatformEnv == Feature || CmpPlatformEnv(PlatformEnv, Feature);
95 
96   return PlatformEnv == Feature;
97 }
98 
99 /// Determine whether a translation unit built using the current
100 /// language options has the given feature.
101 static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
102                        const TargetInfo &Target) {
103   bool HasFeature = llvm::StringSwitch<bool>(Feature)
104                         .Case("altivec", LangOpts.AltiVec)
105                         .Case("blocks", LangOpts.Blocks)
106                         .Case("coroutines", LangOpts.Coroutines)
107                         .Case("cplusplus", LangOpts.CPlusPlus)
108                         .Case("cplusplus11", LangOpts.CPlusPlus11)
109                         .Case("cplusplus14", LangOpts.CPlusPlus14)
110                         .Case("cplusplus17", LangOpts.CPlusPlus17)
111                         .Case("c99", LangOpts.C99)
112                         .Case("c11", LangOpts.C11)
113                         .Case("c17", LangOpts.C17)
114                         .Case("freestanding", LangOpts.Freestanding)
115                         .Case("gnuinlineasm", LangOpts.GNUAsm)
116                         .Case("objc", LangOpts.ObjC)
117                         .Case("objc_arc", LangOpts.ObjCAutoRefCount)
118                         .Case("opencl", LangOpts.OpenCL)
119                         .Case("tls", Target.isTLSSupported())
120                         .Case("zvector", LangOpts.ZVector)
121                         .Default(Target.hasFeature(Feature) ||
122                                  isPlatformEnvironment(Target, Feature));
123   if (!HasFeature)
124     HasFeature = llvm::is_contained(LangOpts.ModuleFeatures, Feature);
125   return HasFeature;
126 }
127 
128 bool Module::isUnimportable(const LangOptions &LangOpts,
129                             const TargetInfo &Target, Requirement &Req,
130                             Module *&ShadowingModule) const {
131   if (!IsUnimportable)
132     return false;
133 
134   for (const Module *Current = this; Current; Current = Current->Parent) {
135     if (Current->ShadowingModule) {
136       ShadowingModule = Current->ShadowingModule;
137       return true;
138     }
139     for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
140       if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
141               Current->Requirements[I].second) {
142         Req = Current->Requirements[I];
143         return true;
144       }
145     }
146   }
147 
148   llvm_unreachable("could not find a reason why module is unimportable");
149 }
150 
151 bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
152                          Requirement &Req,
153                          UnresolvedHeaderDirective &MissingHeader,
154                          Module *&ShadowingModule) const {
155   if (IsAvailable)
156     return true;
157 
158   if (isUnimportable(LangOpts, Target, Req, ShadowingModule))
159     return false;
160 
161   // FIXME: All missing headers are listed on the top-level module. Should we
162   // just look there?
163   for (const Module *Current = this; Current; Current = Current->Parent) {
164     if (!Current->MissingHeaders.empty()) {
165       MissingHeader = Current->MissingHeaders.front();
166       return false;
167     }
168   }
169 
170   llvm_unreachable("could not find a reason why module is unavailable");
171 }
172 
173 bool Module::isSubModuleOf(const Module *Other) const {
174   for (auto *Parent = this; Parent; Parent = Parent->Parent) {
175     if (Parent == Other)
176       return true;
177   }
178   return false;
179 }
180 
181 const Module *Module::getTopLevelModule() const {
182   const Module *Result = this;
183   while (Result->Parent)
184     Result = Result->Parent;
185 
186   return Result;
187 }
188 
189 static StringRef getModuleNameFromComponent(
190     const std::pair<std::string, SourceLocation> &IdComponent) {
191   return IdComponent.first;
192 }
193 
194 static StringRef getModuleNameFromComponent(StringRef R) { return R; }
195 
196 template<typename InputIter>
197 static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End,
198                           bool AllowStringLiterals = true) {
199   for (InputIter It = Begin; It != End; ++It) {
200     if (It != Begin)
201       OS << ".";
202 
203     StringRef Name = getModuleNameFromComponent(*It);
204     if (!AllowStringLiterals || isValidAsciiIdentifier(Name))
205       OS << Name;
206     else {
207       OS << '"';
208       OS.write_escaped(Name);
209       OS << '"';
210     }
211   }
212 }
213 
214 template<typename Container>
215 static void printModuleId(raw_ostream &OS, const Container &C) {
216   return printModuleId(OS, C.begin(), C.end());
217 }
218 
219 std::string Module::getFullModuleName(bool AllowStringLiterals) const {
220   SmallVector<StringRef, 2> Names;
221 
222   // Build up the set of module names (from innermost to outermost).
223   for (const Module *M = this; M; M = M->Parent)
224     Names.push_back(M->Name);
225 
226   std::string Result;
227 
228   llvm::raw_string_ostream Out(Result);
229   printModuleId(Out, Names.rbegin(), Names.rend(), AllowStringLiterals);
230   Out.flush();
231 
232   return Result;
233 }
234 
235 bool Module::fullModuleNameIs(ArrayRef<StringRef> nameParts) const {
236   for (const Module *M = this; M; M = M->Parent) {
237     if (nameParts.empty() || M->Name != nameParts.back())
238       return false;
239     nameParts = nameParts.drop_back();
240   }
241   return nameParts.empty();
242 }
243 
244 Module::DirectoryName Module::getUmbrellaDir() const {
245   if (Header U = getUmbrellaHeader())
246     return {"", "", U.Entry->getDir()};
247 
248   return {UmbrellaAsWritten, UmbrellaRelativeToRootModuleDirectory,
249           Umbrella.dyn_cast<const DirectoryEntry *>()};
250 }
251 
252 void Module::addTopHeader(const FileEntry *File) {
253   assert(File);
254   TopHeaders.insert(File);
255 }
256 
257 ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
258   if (!TopHeaderNames.empty()) {
259     for (std::vector<std::string>::iterator
260            I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
261       if (auto FE = FileMgr.getFile(*I))
262         TopHeaders.insert(*FE);
263     }
264     TopHeaderNames.clear();
265   }
266 
267   return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
268 }
269 
270 bool Module::directlyUses(const Module *Requested) {
271   auto *Top = getTopLevelModule();
272 
273   // A top-level module implicitly uses itself.
274   if (Requested->isSubModuleOf(Top))
275     return true;
276 
277   for (auto *Use : Top->DirectUses)
278     if (Requested->isSubModuleOf(Use))
279       return true;
280 
281   // Anyone is allowed to use our builtin stddef.h and its accompanying module.
282   if (!Requested->Parent && Requested->Name == "_Builtin_stddef_max_align_t")
283     return true;
284 
285   if (NoUndeclaredIncludes)
286     UndeclaredUses.insert(Requested);
287 
288   return false;
289 }
290 
291 void Module::addRequirement(StringRef Feature, bool RequiredState,
292                             const LangOptions &LangOpts,
293                             const TargetInfo &Target) {
294   Requirements.push_back(Requirement(std::string(Feature), RequiredState));
295 
296   // If this feature is currently available, we're done.
297   if (hasFeature(Feature, LangOpts, Target) == RequiredState)
298     return;
299 
300   markUnavailable(/*Unimportable*/true);
301 }
302 
303 void Module::markUnavailable(bool Unimportable) {
304   auto needUpdate = [Unimportable](Module *M) {
305     return M->IsAvailable || (!M->IsUnimportable && Unimportable);
306   };
307 
308   if (!needUpdate(this))
309     return;
310 
311   SmallVector<Module *, 2> Stack;
312   Stack.push_back(this);
313   while (!Stack.empty()) {
314     Module *Current = Stack.back();
315     Stack.pop_back();
316 
317     if (!needUpdate(Current))
318       continue;
319 
320     Current->IsAvailable = false;
321     Current->IsUnimportable |= Unimportable;
322     for (submodule_iterator Sub = Current->submodule_begin(),
323                          SubEnd = Current->submodule_end();
324          Sub != SubEnd; ++Sub) {
325       if (needUpdate(*Sub))
326         Stack.push_back(*Sub);
327     }
328   }
329 }
330 
331 Module *Module::findSubmodule(StringRef Name) const {
332   llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
333   if (Pos == SubModuleIndex.end())
334     return nullptr;
335 
336   return SubModules[Pos->getValue()];
337 }
338 
339 Module *Module::findOrInferSubmodule(StringRef Name) {
340   llvm::StringMap<unsigned>::const_iterator Pos = SubModuleIndex.find(Name);
341   if (Pos != SubModuleIndex.end())
342     return SubModules[Pos->getValue()];
343   if (!InferSubmodules)
344     return nullptr;
345   Module *Result = new Module(Name, SourceLocation(), this, false, InferExplicitSubmodules, 0);
346   Result->InferExplicitSubmodules = InferExplicitSubmodules;
347   Result->InferSubmodules = InferSubmodules;
348   Result->InferExportWildcard = InferExportWildcard;
349   if (Result->InferExportWildcard)
350     Result->Exports.push_back(Module::ExportDecl(nullptr, true));
351   return Result;
352 }
353 
354 void Module::getExportedModules(SmallVectorImpl<Module *> &Exported) const {
355   // All non-explicit submodules are exported.
356   for (std::vector<Module *>::const_iterator I = SubModules.begin(),
357                                              E = SubModules.end();
358        I != E; ++I) {
359     Module *Mod = *I;
360     if (!Mod->IsExplicit)
361       Exported.push_back(Mod);
362   }
363 
364   // Find re-exported modules by filtering the list of imported modules.
365   bool AnyWildcard = false;
366   bool UnrestrictedWildcard = false;
367   SmallVector<Module *, 4> WildcardRestrictions;
368   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
369     Module *Mod = Exports[I].getPointer();
370     if (!Exports[I].getInt()) {
371       // Export a named module directly; no wildcards involved.
372       Exported.push_back(Mod);
373 
374       continue;
375     }
376 
377     // Wildcard export: export all of the imported modules that match
378     // the given pattern.
379     AnyWildcard = true;
380     if (UnrestrictedWildcard)
381       continue;
382 
383     if (Module *Restriction = Exports[I].getPointer())
384       WildcardRestrictions.push_back(Restriction);
385     else {
386       WildcardRestrictions.clear();
387       UnrestrictedWildcard = true;
388     }
389   }
390 
391   // If there were any wildcards, push any imported modules that were
392   // re-exported by the wildcard restriction.
393   if (!AnyWildcard)
394     return;
395 
396   for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
397     Module *Mod = Imports[I];
398     bool Acceptable = UnrestrictedWildcard;
399     if (!Acceptable) {
400       // Check whether this module meets one of the restrictions.
401       for (unsigned R = 0, NR = WildcardRestrictions.size(); R != NR; ++R) {
402         Module *Restriction = WildcardRestrictions[R];
403         if (Mod == Restriction || Mod->isSubModuleOf(Restriction)) {
404           Acceptable = true;
405           break;
406         }
407       }
408     }
409 
410     if (!Acceptable)
411       continue;
412 
413     Exported.push_back(Mod);
414   }
415 }
416 
417 void Module::buildVisibleModulesCache() const {
418   assert(VisibleModulesCache.empty() && "cache does not need building");
419 
420   // This module is visible to itself.
421   VisibleModulesCache.insert(this);
422 
423   // Every imported module is visible.
424   SmallVector<Module *, 16> Stack(Imports.begin(), Imports.end());
425   while (!Stack.empty()) {
426     Module *CurrModule = Stack.pop_back_val();
427 
428     // Every module transitively exported by an imported module is visible.
429     if (VisibleModulesCache.insert(CurrModule).second)
430       CurrModule->getExportedModules(Stack);
431   }
432 }
433 
434 void Module::print(raw_ostream &OS, unsigned Indent, bool Dump) const {
435   OS.indent(Indent);
436   if (IsFramework)
437     OS << "framework ";
438   if (IsExplicit)
439     OS << "explicit ";
440   OS << "module ";
441   printModuleId(OS, &Name, &Name + 1);
442 
443   if (IsSystem || IsExternC) {
444     OS.indent(Indent + 2);
445     if (IsSystem)
446       OS << " [system]";
447     if (IsExternC)
448       OS << " [extern_c]";
449   }
450 
451   OS << " {\n";
452 
453   if (!Requirements.empty()) {
454     OS.indent(Indent + 2);
455     OS << "requires ";
456     for (unsigned I = 0, N = Requirements.size(); I != N; ++I) {
457       if (I)
458         OS << ", ";
459       if (!Requirements[I].second)
460         OS << "!";
461       OS << Requirements[I].first;
462     }
463     OS << "\n";
464   }
465 
466   if (Header H = getUmbrellaHeader()) {
467     OS.indent(Indent + 2);
468     OS << "umbrella header \"";
469     OS.write_escaped(H.NameAsWritten);
470     OS << "\"\n";
471   } else if (DirectoryName D = getUmbrellaDir()) {
472     OS.indent(Indent + 2);
473     OS << "umbrella \"";
474     OS.write_escaped(D.NameAsWritten);
475     OS << "\"\n";
476   }
477 
478   if (!ConfigMacros.empty() || ConfigMacrosExhaustive) {
479     OS.indent(Indent + 2);
480     OS << "config_macros ";
481     if (ConfigMacrosExhaustive)
482       OS << "[exhaustive]";
483     for (unsigned I = 0, N = ConfigMacros.size(); I != N; ++I) {
484       if (I)
485         OS << ", ";
486       OS << ConfigMacros[I];
487     }
488     OS << "\n";
489   }
490 
491   struct {
492     StringRef Prefix;
493     HeaderKind Kind;
494   } Kinds[] = {{"", HK_Normal},
495                {"textual ", HK_Textual},
496                {"private ", HK_Private},
497                {"private textual ", HK_PrivateTextual},
498                {"exclude ", HK_Excluded}};
499 
500   for (auto &K : Kinds) {
501     assert(&K == &Kinds[K.Kind] && "kinds in wrong order");
502     for (auto &H : Headers[K.Kind]) {
503       OS.indent(Indent + 2);
504       OS << K.Prefix << "header \"";
505       OS.write_escaped(H.NameAsWritten);
506       OS << "\" { size " << H.Entry->getSize()
507          << " mtime " << H.Entry->getModificationTime() << " }\n";
508     }
509   }
510   for (auto *Unresolved : {&UnresolvedHeaders, &MissingHeaders}) {
511     for (auto &U : *Unresolved) {
512       OS.indent(Indent + 2);
513       OS << Kinds[U.Kind].Prefix << "header \"";
514       OS.write_escaped(U.FileName);
515       OS << "\"";
516       if (U.Size || U.ModTime) {
517         OS << " {";
518         if (U.Size)
519           OS << " size " << *U.Size;
520         if (U.ModTime)
521           OS << " mtime " << *U.ModTime;
522         OS << " }";
523       }
524       OS << "\n";
525     }
526   }
527 
528   if (!ExportAsModule.empty()) {
529     OS.indent(Indent + 2);
530     OS << "export_as" << ExportAsModule << "\n";
531   }
532 
533   for (submodule_const_iterator MI = submodule_begin(), MIEnd = submodule_end();
534        MI != MIEnd; ++MI)
535     // Print inferred subframework modules so that we don't need to re-infer
536     // them (requires expensive directory iteration + stat calls) when we build
537     // the module. Regular inferred submodules are OK, as we need to look at all
538     // those header files anyway.
539     if (!(*MI)->IsInferred || (*MI)->IsFramework)
540       (*MI)->print(OS, Indent + 2, Dump);
541 
542   for (unsigned I = 0, N = Exports.size(); I != N; ++I) {
543     OS.indent(Indent + 2);
544     OS << "export ";
545     if (Module *Restriction = Exports[I].getPointer()) {
546       OS << Restriction->getFullModuleName(true);
547       if (Exports[I].getInt())
548         OS << ".*";
549     } else {
550       OS << "*";
551     }
552     OS << "\n";
553   }
554 
555   for (unsigned I = 0, N = UnresolvedExports.size(); I != N; ++I) {
556     OS.indent(Indent + 2);
557     OS << "export ";
558     printModuleId(OS, UnresolvedExports[I].Id);
559     if (UnresolvedExports[I].Wildcard)
560       OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");
561     OS << "\n";
562   }
563 
564   if (Dump) {
565     for (Module *M : Imports) {
566       OS.indent(Indent + 2);
567       llvm::errs() << "import " << M->getFullModuleName() << "\n";
568     }
569   }
570 
571   for (unsigned I = 0, N = DirectUses.size(); I != N; ++I) {
572     OS.indent(Indent + 2);
573     OS << "use ";
574     OS << DirectUses[I]->getFullModuleName(true);
575     OS << "\n";
576   }
577 
578   for (unsigned I = 0, N = UnresolvedDirectUses.size(); I != N; ++I) {
579     OS.indent(Indent + 2);
580     OS << "use ";
581     printModuleId(OS, UnresolvedDirectUses[I]);
582     OS << "\n";
583   }
584 
585   for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
586     OS.indent(Indent + 2);
587     OS << "link ";
588     if (LinkLibraries[I].IsFramework)
589       OS << "framework ";
590     OS << "\"";
591     OS.write_escaped(LinkLibraries[I].Library);
592     OS << "\"";
593   }
594 
595   for (unsigned I = 0, N = UnresolvedConflicts.size(); I != N; ++I) {
596     OS.indent(Indent + 2);
597     OS << "conflict ";
598     printModuleId(OS, UnresolvedConflicts[I].Id);
599     OS << ", \"";
600     OS.write_escaped(UnresolvedConflicts[I].Message);
601     OS << "\"\n";
602   }
603 
604   for (unsigned I = 0, N = Conflicts.size(); I != N; ++I) {
605     OS.indent(Indent + 2);
606     OS << "conflict ";
607     OS << Conflicts[I].Other->getFullModuleName(true);
608     OS << ", \"";
609     OS.write_escaped(Conflicts[I].Message);
610     OS << "\"\n";
611   }
612 
613   if (InferSubmodules) {
614     OS.indent(Indent + 2);
615     if (InferExplicitSubmodules)
616       OS << "explicit ";
617     OS << "module * {\n";
618     if (InferExportWildcard) {
619       OS.indent(Indent + 4);
620       OS << "export *\n";
621     }
622     OS.indent(Indent + 2);
623     OS << "}\n";
624   }
625 
626   OS.indent(Indent);
627   OS << "}\n";
628 }
629 
630 LLVM_DUMP_METHOD void Module::dump() const {
631   print(llvm::errs(), 0, true);
632 }
633 
634 void VisibleModuleSet::setVisible(Module *M, SourceLocation Loc,
635                                   VisibleCallback Vis, ConflictCallback Cb) {
636   assert(Loc.isValid() && "setVisible expects a valid import location");
637   if (isVisible(M))
638     return;
639 
640   ++Generation;
641 
642   struct Visiting {
643     Module *M;
644     Visiting *ExportedBy;
645   };
646 
647   std::function<void(Visiting)> VisitModule = [&](Visiting V) {
648     // Nothing to do for a module that's already visible.
649     unsigned ID = V.M->getVisibilityID();
650     if (ImportLocs.size() <= ID)
651       ImportLocs.resize(ID + 1);
652     else if (ImportLocs[ID].isValid())
653       return;
654 
655     ImportLocs[ID] = Loc;
656     Vis(M);
657 
658     // Make any exported modules visible.
659     SmallVector<Module *, 16> Exports;
660     V.M->getExportedModules(Exports);
661     for (Module *E : Exports) {
662       // Don't import non-importable modules.
663       if (!E->isUnimportable())
664         VisitModule({E, &V});
665     }
666 
667     for (auto &C : V.M->Conflicts) {
668       if (isVisible(C.Other)) {
669         llvm::SmallVector<Module*, 8> Path;
670         for (Visiting *I = &V; I; I = I->ExportedBy)
671           Path.push_back(I->M);
672         Cb(Path, C.Other, C.Message);
673       }
674     }
675   };
676   VisitModule({M, nullptr});
677 }
678 
679 ASTSourceDescriptor::ASTSourceDescriptor(Module &M)
680     : Signature(M.Signature), ClangModule(&M) {
681   if (M.Directory)
682     Path = M.Directory->getName();
683   if (auto File = M.getASTFile())
684     ASTFile = File->getName();
685 }
686 
687 std::string ASTSourceDescriptor::getModuleName() const {
688   if (ClangModule)
689     return ClangModule->Name;
690   else
691     return std::string(PCHModuleName);
692 }
693