contrib/llvm/tools/clang/lib/Basic/Module.cpp

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