1 //===- Module.h - Describe a module -----------------------------*- C++ -*-===// 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 /// \file 10 /// Defines the clang::Module class, which describes a module in the 11 /// source code. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_BASIC_MODULE_H 16 #define LLVM_CLANG_BASIC_MODULE_H 17 18 #include "clang/Basic/DirectoryEntry.h" 19 #include "clang/Basic/FileEntry.h" 20 #include "clang/Basic/SourceLocation.h" 21 #include "llvm/ADT/ArrayRef.h" 22 #include "llvm/ADT/DenseSet.h" 23 #include "llvm/ADT/Optional.h" 24 #include "llvm/ADT/PointerIntPair.h" 25 #include "llvm/ADT/STLExtras.h" 26 #include "llvm/ADT/SetVector.h" 27 #include "llvm/ADT/SmallVector.h" 28 #include "llvm/ADT/StringMap.h" 29 #include "llvm/ADT/StringRef.h" 30 #include "llvm/ADT/iterator_range.h" 31 #include <array> 32 #include <cassert> 33 #include <cstdint> 34 #include <ctime> 35 #include <iterator> 36 #include <string> 37 #include <utility> 38 #include <vector> 39 40 namespace llvm { 41 42 class raw_ostream; 43 44 } // namespace llvm 45 46 namespace clang { 47 48 class FileManager; 49 class LangOptions; 50 class TargetInfo; 51 52 /// Describes the name of a module. 53 using ModuleId = SmallVector<std::pair<std::string, SourceLocation>, 2>; 54 55 /// The signature of a module, which is a hash of the AST content. 56 struct ASTFileSignature : std::array<uint8_t, 20> { 57 using BaseT = std::array<uint8_t, 20>; 58 59 static constexpr size_t size = std::tuple_size<BaseT>::value; 60 BaseTASTFileSignature61 ASTFileSignature(BaseT S = {{0}}) : BaseT(std::move(S)) {} 62 63 explicit operator bool() const { return *this != BaseT({{0}}); } 64 65 /// Returns the value truncated to the size of an uint64_t. truncatedValueASTFileSignature66 uint64_t truncatedValue() const { 67 uint64_t Value = 0; 68 static_assert(sizeof(*this) >= sizeof(uint64_t), "No need to truncate."); 69 for (unsigned I = 0; I < sizeof(uint64_t); ++I) 70 Value |= static_cast<uint64_t>((*this)[I]) << (I * 8); 71 return Value; 72 } 73 createASTFileSignature74 static ASTFileSignature create(StringRef Bytes) { 75 return create(Bytes.bytes_begin(), Bytes.bytes_end()); 76 } 77 createDISentinelASTFileSignature78 static ASTFileSignature createDISentinel() { 79 ASTFileSignature Sentinel; 80 Sentinel.fill(0xFF); 81 return Sentinel; 82 } 83 84 template <typename InputIt> createASTFileSignature85 static ASTFileSignature create(InputIt First, InputIt Last) { 86 assert(std::distance(First, Last) == size && 87 "Wrong amount of bytes to create an ASTFileSignature"); 88 89 ASTFileSignature Signature; 90 std::copy(First, Last, Signature.begin()); 91 return Signature; 92 } 93 }; 94 95 /// Describes a module or submodule. 96 class Module { 97 public: 98 /// The name of this module. 99 std::string Name; 100 101 /// The location of the module definition. 102 SourceLocation DefinitionLoc; 103 104 enum ModuleKind { 105 /// This is a module that was defined by a module map and built out 106 /// of header files. 107 ModuleMapModule, 108 109 /// This is a C++ Modules TS module interface unit. 110 ModuleInterfaceUnit, 111 112 /// This is a fragment of the global module within some C++ module. 113 GlobalModuleFragment, 114 115 /// This is the private module fragment within some C++ module. 116 PrivateModuleFragment, 117 }; 118 119 /// The kind of this module. 120 ModuleKind Kind = ModuleMapModule; 121 122 /// The parent of this module. This will be NULL for the top-level 123 /// module. 124 Module *Parent; 125 126 /// The build directory of this module. This is the directory in 127 /// which the module is notionally built, and relative to which its headers 128 /// are found. 129 const DirectoryEntry *Directory = nullptr; 130 131 /// The presumed file name for the module map defining this module. 132 /// Only non-empty when building from preprocessed source. 133 std::string PresumedModuleMapFile; 134 135 /// The umbrella header or directory. 136 llvm::PointerUnion<const FileEntry *, const DirectoryEntry *> Umbrella; 137 138 /// The module signature. 139 ASTFileSignature Signature; 140 141 /// The name of the umbrella entry, as written in the module map. 142 std::string UmbrellaAsWritten; 143 144 /// The module through which entities defined in this module will 145 /// eventually be exposed, for use in "private" modules. 146 std::string ExportAsModule; 147 148 /// Does this Module scope describe part of the purview of a named C++ module? isModulePurview()149 bool isModulePurview() const { 150 return Kind == ModuleInterfaceUnit || Kind == PrivateModuleFragment; 151 } 152 153 private: 154 /// The submodules of this module, indexed by name. 155 std::vector<Module *> SubModules; 156 157 /// A mapping from the submodule name to the index into the 158 /// \c SubModules vector at which that submodule resides. 159 llvm::StringMap<unsigned> SubModuleIndex; 160 161 /// The AST file if this is a top-level module which has a 162 /// corresponding serialized AST file, or null otherwise. 163 Optional<FileEntryRef> ASTFile; 164 165 /// The top-level headers associated with this module. 166 llvm::SmallSetVector<const FileEntry *, 2> TopHeaders; 167 168 /// top-level header filenames that aren't resolved to FileEntries yet. 169 std::vector<std::string> TopHeaderNames; 170 171 /// Cache of modules visible to lookup in this module. 172 mutable llvm::DenseSet<const Module*> VisibleModulesCache; 173 174 /// The ID used when referencing this module within a VisibleModuleSet. 175 unsigned VisibilityID; 176 177 public: 178 enum HeaderKind { 179 HK_Normal, 180 HK_Textual, 181 HK_Private, 182 HK_PrivateTextual, 183 HK_Excluded 184 }; 185 static const int NumHeaderKinds = HK_Excluded + 1; 186 187 /// Information about a header directive as found in the module map 188 /// file. 189 struct Header { 190 std::string NameAsWritten; 191 const FileEntry *Entry; 192 193 explicit operator bool() { return Entry; } 194 }; 195 196 /// Information about a directory name as found in the module map 197 /// file. 198 struct DirectoryName { 199 std::string NameAsWritten; 200 const DirectoryEntry *Entry; 201 202 explicit operator bool() { return Entry; } 203 }; 204 205 /// The headers that are part of this module. 206 SmallVector<Header, 2> Headers[5]; 207 208 /// Stored information about a header directive that was found in the 209 /// module map file but has not been resolved to a file. 210 struct UnresolvedHeaderDirective { 211 HeaderKind Kind = HK_Normal; 212 SourceLocation FileNameLoc; 213 std::string FileName; 214 bool IsUmbrella = false; 215 bool HasBuiltinHeader = false; 216 Optional<off_t> Size; 217 Optional<time_t> ModTime; 218 }; 219 220 /// Headers that are mentioned in the module map file but that we have not 221 /// yet attempted to resolve to a file on the file system. 222 SmallVector<UnresolvedHeaderDirective, 1> UnresolvedHeaders; 223 224 /// Headers that are mentioned in the module map file but could not be 225 /// found on the file system. 226 SmallVector<UnresolvedHeaderDirective, 1> MissingHeaders; 227 228 /// An individual requirement: a feature name and a flag indicating 229 /// the required state of that feature. 230 using Requirement = std::pair<std::string, bool>; 231 232 /// The set of language features required to use this module. 233 /// 234 /// If any of these requirements are not available, the \c IsAvailable bit 235 /// will be false to indicate that this (sub)module is not available. 236 SmallVector<Requirement, 2> Requirements; 237 238 /// A module with the same name that shadows this module. 239 Module *ShadowingModule = nullptr; 240 241 /// Whether this module has declared itself unimportable, either because 242 /// it's missing a requirement from \p Requirements or because it's been 243 /// shadowed by another module. 244 unsigned IsUnimportable : 1; 245 246 /// Whether we tried and failed to load a module file for this module. 247 unsigned HasIncompatibleModuleFile : 1; 248 249 /// Whether this module is available in the current translation unit. 250 /// 251 /// If the module is missing headers or does not meet all requirements then 252 /// this bit will be 0. 253 unsigned IsAvailable : 1; 254 255 /// Whether this module was loaded from a module file. 256 unsigned IsFromModuleFile : 1; 257 258 /// Whether this is a framework module. 259 unsigned IsFramework : 1; 260 261 /// Whether this is an explicit submodule. 262 unsigned IsExplicit : 1; 263 264 /// Whether this is a "system" module (which assumes that all 265 /// headers in it are system headers). 266 unsigned IsSystem : 1; 267 268 /// Whether this is an 'extern "C"' module (which implicitly puts all 269 /// headers in it within an 'extern "C"' block, and allows the module to be 270 /// imported within such a block). 271 unsigned IsExternC : 1; 272 273 /// Whether this is an inferred submodule (module * { ... }). 274 unsigned IsInferred : 1; 275 276 /// Whether we should infer submodules for this module based on 277 /// the headers. 278 /// 279 /// Submodules can only be inferred for modules with an umbrella header. 280 unsigned InferSubmodules : 1; 281 282 /// Whether, when inferring submodules, the inferred submodules 283 /// should be explicit. 284 unsigned InferExplicitSubmodules : 1; 285 286 /// Whether, when inferring submodules, the inferr submodules should 287 /// export all modules they import (e.g., the equivalent of "export *"). 288 unsigned InferExportWildcard : 1; 289 290 /// Whether the set of configuration macros is exhaustive. 291 /// 292 /// When the set of configuration macros is exhaustive, meaning 293 /// that no identifier not in this list should affect how the module is 294 /// built. 295 unsigned ConfigMacrosExhaustive : 1; 296 297 /// Whether files in this module can only include non-modular headers 298 /// and headers from used modules. 299 unsigned NoUndeclaredIncludes : 1; 300 301 /// Whether this module came from a "private" module map, found next 302 /// to a regular (public) module map. 303 unsigned ModuleMapIsPrivate : 1; 304 305 /// Describes the visibility of the various names within a 306 /// particular module. 307 enum NameVisibilityKind { 308 /// All of the names in this module are hidden. 309 Hidden, 310 /// All of the names in this module are visible. 311 AllVisible 312 }; 313 314 /// The visibility of names within this particular module. 315 NameVisibilityKind NameVisibility; 316 317 /// The location of the inferred submodule. 318 SourceLocation InferredSubmoduleLoc; 319 320 /// The set of modules imported by this module, and on which this 321 /// module depends. 322 llvm::SmallSetVector<Module *, 2> Imports; 323 324 /// Describes an exported module. 325 /// 326 /// The pointer is the module being re-exported, while the bit will be true 327 /// to indicate that this is a wildcard export. 328 using ExportDecl = llvm::PointerIntPair<Module *, 1, bool>; 329 330 /// The set of export declarations. 331 SmallVector<ExportDecl, 2> Exports; 332 333 /// Describes an exported module that has not yet been resolved 334 /// (perhaps because the module it refers to has not yet been loaded). 335 struct UnresolvedExportDecl { 336 /// The location of the 'export' keyword in the module map file. 337 SourceLocation ExportLoc; 338 339 /// The name of the module. 340 ModuleId Id; 341 342 /// Whether this export declaration ends in a wildcard, indicating 343 /// that all of its submodules should be exported (rather than the named 344 /// module itself). 345 bool Wildcard; 346 }; 347 348 /// The set of export declarations that have yet to be resolved. 349 SmallVector<UnresolvedExportDecl, 2> UnresolvedExports; 350 351 /// The directly used modules. 352 SmallVector<Module *, 2> DirectUses; 353 354 /// The set of use declarations that have yet to be resolved. 355 SmallVector<ModuleId, 2> UnresolvedDirectUses; 356 357 /// A library or framework to link against when an entity from this 358 /// module is used. 359 struct LinkLibrary { 360 LinkLibrary() = default; LinkLibraryLinkLibrary361 LinkLibrary(const std::string &Library, bool IsFramework) 362 : Library(Library), IsFramework(IsFramework) {} 363 364 /// The library to link against. 365 /// 366 /// This will typically be a library or framework name, but can also 367 /// be an absolute path to the library or framework. 368 std::string Library; 369 370 /// Whether this is a framework rather than a library. 371 bool IsFramework = false; 372 }; 373 374 /// The set of libraries or frameworks to link against when 375 /// an entity from this module is used. 376 llvm::SmallVector<LinkLibrary, 2> LinkLibraries; 377 378 /// Autolinking uses the framework name for linking purposes 379 /// when this is false and the export_as name otherwise. 380 bool UseExportAsModuleLinkName = false; 381 382 /// The set of "configuration macros", which are macros that 383 /// (intentionally) change how this module is built. 384 std::vector<std::string> ConfigMacros; 385 386 /// An unresolved conflict with another module. 387 struct UnresolvedConflict { 388 /// The (unresolved) module id. 389 ModuleId Id; 390 391 /// The message provided to the user when there is a conflict. 392 std::string Message; 393 }; 394 395 /// The list of conflicts for which the module-id has not yet been 396 /// resolved. 397 std::vector<UnresolvedConflict> UnresolvedConflicts; 398 399 /// A conflict between two modules. 400 struct Conflict { 401 /// The module that this module conflicts with. 402 Module *Other; 403 404 /// The message provided to the user when there is a conflict. 405 std::string Message; 406 }; 407 408 /// The list of conflicts. 409 std::vector<Conflict> Conflicts; 410 411 /// Construct a new module or submodule. 412 Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, 413 bool IsFramework, bool IsExplicit, unsigned VisibilityID); 414 415 ~Module(); 416 417 /// Determine whether this module has been declared unimportable. isUnimportable()418 bool isUnimportable() const { return IsUnimportable; } 419 420 /// Determine whether this module has been declared unimportable. 421 /// 422 /// \param LangOpts The language options used for the current 423 /// translation unit. 424 /// 425 /// \param Target The target options used for the current translation unit. 426 /// 427 /// \param Req If this module is unimportable because of a missing 428 /// requirement, this parameter will be set to one of the requirements that 429 /// is not met for use of this module. 430 /// 431 /// \param ShadowingModule If this module is unimportable because it is 432 /// shadowed, this parameter will be set to the shadowing module. 433 bool isUnimportable(const LangOptions &LangOpts, const TargetInfo &Target, 434 Requirement &Req, Module *&ShadowingModule) const; 435 436 /// Determine whether this module is available for use within the 437 /// current translation unit. isAvailable()438 bool isAvailable() const { return IsAvailable; } 439 440 /// Determine whether this module is available for use within the 441 /// current translation unit. 442 /// 443 /// \param LangOpts The language options used for the current 444 /// translation unit. 445 /// 446 /// \param Target The target options used for the current translation unit. 447 /// 448 /// \param Req If this module is unavailable because of a missing requirement, 449 /// this parameter will be set to one of the requirements that is not met for 450 /// use of this module. 451 /// 452 /// \param MissingHeader If this module is unavailable because of a missing 453 /// header, this parameter will be set to one of the missing headers. 454 /// 455 /// \param ShadowingModule If this module is unavailable because it is 456 /// shadowed, this parameter will be set to the shadowing module. 457 bool isAvailable(const LangOptions &LangOpts, 458 const TargetInfo &Target, 459 Requirement &Req, 460 UnresolvedHeaderDirective &MissingHeader, 461 Module *&ShadowingModule) const; 462 463 /// Determine whether this module is a submodule. isSubModule()464 bool isSubModule() const { return Parent != nullptr; } 465 466 /// Check if this module is a (possibly transitive) submodule of \p Other. 467 /// 468 /// The 'A is a submodule of B' relation is a partial order based on the 469 /// the parent-child relationship between individual modules. 470 /// 471 /// Returns \c false if \p Other is \c nullptr. 472 bool isSubModuleOf(const Module *Other) const; 473 474 /// Determine whether this module is a part of a framework, 475 /// either because it is a framework module or because it is a submodule 476 /// of a framework module. isPartOfFramework()477 bool isPartOfFramework() const { 478 for (const Module *Mod = this; Mod; Mod = Mod->Parent) 479 if (Mod->IsFramework) 480 return true; 481 482 return false; 483 } 484 485 /// Determine whether this module is a subframework of another 486 /// framework. isSubFramework()487 bool isSubFramework() const { 488 return IsFramework && Parent && Parent->isPartOfFramework(); 489 } 490 491 /// Set the parent of this module. This should only be used if the parent 492 /// could not be set during module creation. setParent(Module * M)493 void setParent(Module *M) { 494 assert(!Parent); 495 Parent = M; 496 Parent->SubModuleIndex[Name] = Parent->SubModules.size(); 497 Parent->SubModules.push_back(this); 498 } 499 500 /// Retrieve the full name of this module, including the path from 501 /// its top-level module. 502 /// \param AllowStringLiterals If \c true, components that might not be 503 /// lexically valid as identifiers will be emitted as string literals. 504 std::string getFullModuleName(bool AllowStringLiterals = false) const; 505 506 /// Whether the full name of this module is equal to joining 507 /// \p nameParts with "."s. 508 /// 509 /// This is more efficient than getFullModuleName(). 510 bool fullModuleNameIs(ArrayRef<StringRef> nameParts) const; 511 512 /// Retrieve the top-level module for this (sub)module, which may 513 /// be this module. getTopLevelModule()514 Module *getTopLevelModule() { 515 return const_cast<Module *>( 516 const_cast<const Module *>(this)->getTopLevelModule()); 517 } 518 519 /// Retrieve the top-level module for this (sub)module, which may 520 /// be this module. 521 const Module *getTopLevelModule() const; 522 523 /// Retrieve the name of the top-level module. getTopLevelModuleName()524 StringRef getTopLevelModuleName() const { 525 return getTopLevelModule()->Name; 526 } 527 528 /// The serialized AST file for this module, if one was created. getASTFile()529 OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const { 530 return getTopLevelModule()->ASTFile; 531 } 532 533 /// Set the serialized AST file for the top-level module of this module. setASTFile(Optional<FileEntryRef> File)534 void setASTFile(Optional<FileEntryRef> File) { 535 assert((!File || !getASTFile() || getASTFile() == File) && 536 "file path changed"); 537 getTopLevelModule()->ASTFile = File; 538 } 539 540 /// Retrieve the directory for which this module serves as the 541 /// umbrella. 542 DirectoryName getUmbrellaDir() const; 543 544 /// Retrieve the header that serves as the umbrella header for this 545 /// module. getUmbrellaHeader()546 Header getUmbrellaHeader() const { 547 if (auto *FE = Umbrella.dyn_cast<const FileEntry *>()) 548 return Header{UmbrellaAsWritten, FE}; 549 return Header{}; 550 } 551 552 /// Determine whether this module has an umbrella directory that is 553 /// not based on an umbrella header. hasUmbrellaDir()554 bool hasUmbrellaDir() const { 555 return Umbrella && Umbrella.is<const DirectoryEntry *>(); 556 } 557 558 /// Add a top-level header associated with this module. 559 void addTopHeader(const FileEntry *File); 560 561 /// Add a top-level header filename associated with this module. addTopHeaderFilename(StringRef Filename)562 void addTopHeaderFilename(StringRef Filename) { 563 TopHeaderNames.push_back(std::string(Filename)); 564 } 565 566 /// The top-level headers associated with this module. 567 ArrayRef<const FileEntry *> getTopHeaders(FileManager &FileMgr); 568 569 /// Determine whether this module has declared its intention to 570 /// directly use another module. 571 bool directlyUses(const Module *Requested) const; 572 573 /// Add the given feature requirement to the list of features 574 /// required by this module. 575 /// 576 /// \param Feature The feature that is required by this module (and 577 /// its submodules). 578 /// 579 /// \param RequiredState The required state of this feature: \c true 580 /// if it must be present, \c false if it must be absent. 581 /// 582 /// \param LangOpts The set of language options that will be used to 583 /// evaluate the availability of this feature. 584 /// 585 /// \param Target The target options that will be used to evaluate the 586 /// availability of this feature. 587 void addRequirement(StringRef Feature, bool RequiredState, 588 const LangOptions &LangOpts, 589 const TargetInfo &Target); 590 591 /// Mark this module and all of its submodules as unavailable. 592 void markUnavailable(bool Unimportable); 593 594 /// Find the submodule with the given name. 595 /// 596 /// \returns The submodule if found, or NULL otherwise. 597 Module *findSubmodule(StringRef Name) const; 598 Module *findOrInferSubmodule(StringRef Name); 599 600 /// Determine whether the specified module would be visible to 601 /// a lookup at the end of this module. 602 /// 603 /// FIXME: This may return incorrect results for (submodules of) the 604 /// module currently being built, if it's queried before we see all 605 /// of its imports. isModuleVisible(const Module * M)606 bool isModuleVisible(const Module *M) const { 607 if (VisibleModulesCache.empty()) 608 buildVisibleModulesCache(); 609 return VisibleModulesCache.count(M); 610 } 611 getVisibilityID()612 unsigned getVisibilityID() const { return VisibilityID; } 613 614 using submodule_iterator = std::vector<Module *>::iterator; 615 using submodule_const_iterator = std::vector<Module *>::const_iterator; 616 submodule_begin()617 submodule_iterator submodule_begin() { return SubModules.begin(); } submodule_begin()618 submodule_const_iterator submodule_begin() const {return SubModules.begin();} submodule_end()619 submodule_iterator submodule_end() { return SubModules.end(); } submodule_end()620 submodule_const_iterator submodule_end() const { return SubModules.end(); } 621 submodules()622 llvm::iterator_range<submodule_iterator> submodules() { 623 return llvm::make_range(submodule_begin(), submodule_end()); 624 } submodules()625 llvm::iterator_range<submodule_const_iterator> submodules() const { 626 return llvm::make_range(submodule_begin(), submodule_end()); 627 } 628 629 /// Appends this module's list of exported modules to \p Exported. 630 /// 631 /// This provides a subset of immediately imported modules (the ones that are 632 /// directly exported), not the complete set of exported modules. 633 void getExportedModules(SmallVectorImpl<Module *> &Exported) const; 634 getModuleInputBufferName()635 static StringRef getModuleInputBufferName() { 636 return "<module-includes>"; 637 } 638 639 /// Print the module map for this module to the given stream. 640 void print(raw_ostream &OS, unsigned Indent = 0) const; 641 642 /// Dump the contents of this module to the given output stream. 643 void dump() const; 644 645 private: 646 void buildVisibleModulesCache() const; 647 }; 648 649 /// A set of visible modules. 650 class VisibleModuleSet { 651 public: 652 VisibleModuleSet() = default; VisibleModuleSet(VisibleModuleSet && O)653 VisibleModuleSet(VisibleModuleSet &&O) 654 : ImportLocs(std::move(O.ImportLocs)), Generation(O.Generation ? 1 : 0) { 655 O.ImportLocs.clear(); 656 ++O.Generation; 657 } 658 659 /// Move from another visible modules set. Guaranteed to leave the source 660 /// empty and bump the generation on both. 661 VisibleModuleSet &operator=(VisibleModuleSet &&O) { 662 ImportLocs = std::move(O.ImportLocs); 663 O.ImportLocs.clear(); 664 ++O.Generation; 665 ++Generation; 666 return *this; 667 } 668 669 /// Get the current visibility generation. Incremented each time the 670 /// set of visible modules changes in any way. getGeneration()671 unsigned getGeneration() const { return Generation; } 672 673 /// Determine whether a module is visible. isVisible(const Module * M)674 bool isVisible(const Module *M) const { 675 return getImportLoc(M).isValid(); 676 } 677 678 /// Get the location at which the import of a module was triggered. getImportLoc(const Module * M)679 SourceLocation getImportLoc(const Module *M) const { 680 return M->getVisibilityID() < ImportLocs.size() 681 ? ImportLocs[M->getVisibilityID()] 682 : SourceLocation(); 683 } 684 685 /// A callback to call when a module is made visible (directly or 686 /// indirectly) by a call to \ref setVisible. 687 using VisibleCallback = llvm::function_ref<void(Module *M)>; 688 689 /// A callback to call when a module conflict is found. \p Path 690 /// consists of a sequence of modules from the conflicting module to the one 691 /// made visible, where each was exported by the next. 692 using ConflictCallback = 693 llvm::function_ref<void(ArrayRef<Module *> Path, Module *Conflict, 694 StringRef Message)>; 695 696 /// Make a specific module visible. 697 void setVisible(Module *M, SourceLocation Loc, 698 VisibleCallback Vis = [](Module *) {}, 699 ConflictCallback Cb = [](ArrayRef<Module *>, Module *, 700 StringRef) {}); 701 702 private: 703 /// Import locations for each visible module. Indexed by the module's 704 /// VisibilityID. 705 std::vector<SourceLocation> ImportLocs; 706 707 /// Visibility generation, bumped every time the visibility state changes. 708 unsigned Generation = 0; 709 }; 710 711 /// Abstracts clang modules and precompiled header files and holds 712 /// everything needed to generate debug info for an imported module 713 /// or PCH. 714 class ASTSourceDescriptor { 715 StringRef PCHModuleName; 716 StringRef Path; 717 StringRef ASTFile; 718 ASTFileSignature Signature; 719 Module *ClangModule = nullptr; 720 721 public: 722 ASTSourceDescriptor() = default; ASTSourceDescriptor(StringRef Name,StringRef Path,StringRef ASTFile,ASTFileSignature Signature)723 ASTSourceDescriptor(StringRef Name, StringRef Path, StringRef ASTFile, 724 ASTFileSignature Signature) 725 : PCHModuleName(std::move(Name)), Path(std::move(Path)), 726 ASTFile(std::move(ASTFile)), Signature(Signature) {} 727 ASTSourceDescriptor(Module &M); 728 729 std::string getModuleName() const; getPath()730 StringRef getPath() const { return Path; } getASTFile()731 StringRef getASTFile() const { return ASTFile; } getSignature()732 ASTFileSignature getSignature() const { return Signature; } getModuleOrNull()733 Module *getModuleOrNull() const { return ClangModule; } 734 }; 735 736 737 } // namespace clang 738 739 #endif // LLVM_CLANG_BASIC_MODULE_H 740