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
40namespace llvm {
41
42class raw_ostream;
43
44} // namespace llvm
45
46namespace clang {
47
48class FileManager;
49class LangOptions;
50class TargetInfo;
51
52/// Describes the name of a module.
53using ModuleId = SmallVector<std::pair<std::string, SourceLocation>, 2>;
54
55/// The signature of a module, which is a hash of the AST content.
56struct 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
61 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.
66 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
74 static ASTFileSignature create(StringRef Bytes) {
75 return create(Bytes.bytes_begin(), Bytes.bytes_end());
76 }
77
78 static ASTFileSignature createDISentinel() {
79 ASTFileSignature Sentinel;
80 Sentinel.fill(0xFF);
81 return Sentinel;
82 }
83
84 template <typename InputIt>
85 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.
96class Module {
97public:
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?
149 bool isModulePurview() const {
150 return Kind == ModuleInterfaceUnit || Kind == PrivateModuleFragment;
151 }
152
153private:
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
177public:
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;
361 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.
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.
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.
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.
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.
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.
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.
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.
524 StringRef getTopLevelModuleName() const {
525 return getTopLevelModule()->Name;
526 }
527
528 /// The serialized AST file for this module, if one was created.
529 OptionalFileEntryRefDegradesToFileEntryPtr getASTFile() const {
530 return getTopLevelModule()->ASTFile;
531 }
532
533 /// Set the serialized AST file for the top-level module of this module.
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.
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.
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.
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.
606 bool isModuleVisible(const Module *M) const {
607 if (VisibleModulesCache.empty())
608 buildVisibleModulesCache();
609 return VisibleModulesCache.count(M);
610 }
611
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
617 submodule_iterator submodule_begin() { return SubModules.begin(); }
618 submodule_const_iterator submodule_begin() const {return SubModules.begin();}
619 submodule_iterator submodule_end() { return SubModules.end(); }
620 submodule_const_iterator submodule_end() const { return SubModules.end(); }
621
622 llvm::iterator_range<submodule_iterator> submodules() {
623 return llvm::make_range(submodule_begin(), submodule_end());
624 }
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
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, bool Dump = false) const;
641
642 /// Dump the contents of this module to the given output stream.
643 void dump() const;
644
645private:
646 void buildVisibleModulesCache() const;
647};
648
649/// A set of visible modules.
650class VisibleModuleSet {
651public:
652 VisibleModuleSet() = default;
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.
671 unsigned getGeneration() const { return Generation; }
672
673 /// Determine whether a module is visible.
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.
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
702private:
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.
714class ASTSourceDescriptor {
715 StringRef PCHModuleName;
716 StringRef Path;
717 StringRef ASTFile;
718 ASTFileSignature Signature;
719 Module *ClangModule = nullptr;
720
721public:
722 ASTSourceDescriptor() = default;
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;
730 StringRef getPath() const { return Path; }
731 StringRef getASTFile() const { return ASTFile; }
732 ASTFileSignature getSignature() const { return Signature; }
733 Module *getModuleOrNull() const { return ClangModule; }
734};
735
736
737} // namespace clang
738
739#endif // LLVM_CLANG_BASIC_MODULE_H
740