Module.h Source File (original) (raw)

15#ifndef LLVM_CLANG_BASIC_MODULE_H

16#define LLVM_CLANG_BASIC_MODULE_H

21#include "llvm/ADT/ArrayRef.h"

22#include "llvm/ADT/DenseSet.h"

23#include "llvm/ADT/PointerIntPair.h"

24#include "llvm/ADT/STLExtras.h"

25#include "llvm/ADT/SetVector.h"

26#include "llvm/ADT/SmallVector.h"

27#include "llvm/ADT/StringMap.h"

28#include "llvm/ADT/StringRef.h"

29#include "llvm/ADT/iterator_range.h"

30#include

31#include

32#include

33#include

34#include

35#include

36#include

37#include

38#include

39#include

41namespace llvm {

43class raw_ostream;

45}

59 using BaseT = std::array<uint8_t, 20>;

61 static constexpr size_t size = std::tuple_size::value;

65 explicit operator bool() const { return *this != BaseT({{0}}); }

74 uint64_t Value = 0;

75 static_assert(sizeof(*this) >= sizeof(uint64_t), "No need to truncate.");

76 for (unsigned I = 0; I < sizeof(uint64_t); ++I)

77 Value |= static_cast<uint64_t>((*this)[I]) << (I * 8);

79 }

87 Sentinel.fill(0xFF);

88 return Sentinel;

89 }

93 Dummy.fill(0x00);

94 return Dummy;

95 }

97 template

100 "Wrong amount of bytes to create an ASTFileSignature");

101

103 std::copy(First, Last, Signature.begin());

104 return Signature;

105 }

106};

107

108

110

111 LLVM_PREFERRED_TYPE(bool)

113

114

115 LLVM_PREFERRED_TYPE(bool)

117

118

119 LLVM_PREFERRED_TYPE(bool)

121

122

123

124 LLVM_PREFERRED_TYPE(bool)

126

130};

131

132

133

134

135

136class ModuleConstructorTag {

137 explicit ModuleConstructorTag() = default;

138 friend ModuleMap;

139};

140

141

142

143

145public:

146

148

149

151

152

153

154

156

157

159

160

162

163

165

166

168

169

171

172

174

175

176

178

179

181

182

183

184

186 };

187

188

190

191

192

194

195

196

197

199

200

201

203

204

205 std::variant<std::monostate, FileEntryRef, DirectoryEntryRef> Umbrella;

206

207

209

210

212

213

215

216

217

219

220

222

223

225 switch (Kind) {

231 return true;

232 default:

233 return false;

234 }

235 }

236

237

238

248

250

252

253private:

254

255 std::vector<Module *> SubModules;

256

257

258

259 mutable llvm::StringMap SubModuleIndex;

260

261

262

264

265

267

268

269 std::vectorstd::string TopHeaderNames;

270

271

272 mutable llvm::DenseSet<const Module*> VisibleModulesCache;

273

274

275 unsigned VisibilityID;

276

277public:

285

286

292

293private:

294 static const int NumHeaderKinds = HK_Excluded + 1;

295

296

297 unsigned HeaderKindBeginIndex[NumHeaderKinds + 1] = {};

299

300public:

303 assert(HK < NumHeaderKinds && "Invalid Module::HeaderKind");

304 auto BeginIt = HeadersStorage.begin() + HeaderKindBeginIndex[HK];

305 auto EndIt = HeadersStorage.begin() + HeaderKindBeginIndex[HK + 1];

306 return {BeginIt, EndIt};

307 }

309 assert(HK < NumHeaderKinds && "Invalid Module::HeaderKind");

310 auto EndIt = HeadersStorage.begin() + HeaderKindBeginIndex[HK + 1];

311 HeadersStorage.insert(EndIt, std::move(H));

312 for (unsigned HKI = HK + 1; HKI != NumHeaderKinds + 1; ++HKI)

313 ++HeaderKindBeginIndex[HKI];

314 }

315

316

322

323

324

331 std::optional<off_t> Size;

333 };

334

335

336

338

339

340

342

347

348

349

350

351

353

354

356

357

358

359

360 LLVM_PREFERRED_TYPE(bool)

362

363

364 LLVM_PREFERRED_TYPE(bool)

366

367

368

369

370

371 LLVM_PREFERRED_TYPE(bool)

373

374

375 LLVM_PREFERRED_TYPE(bool)

377

378

379 LLVM_PREFERRED_TYPE(bool)

381

382

383 LLVM_PREFERRED_TYPE(bool)

385

386

387

388 LLVM_PREFERRED_TYPE(bool)

390

391

392

393

394 LLVM_PREFERRED_TYPE(bool)

396

397

398 LLVM_PREFERRED_TYPE(bool)

400

401

402

403

404

405 LLVM_PREFERRED_TYPE(bool)

407

408

409

410 LLVM_PREFERRED_TYPE(bool)

412

413

414

415 LLVM_PREFERRED_TYPE(bool)

417

418

419

420

421

422

423 LLVM_PREFERRED_TYPE(bool)

425

426

427

428 LLVM_PREFERRED_TYPE(bool)

430

431

432

433 LLVM_PREFERRED_TYPE(bool)

435

436

437

438 LLVM_PREFERRED_TYPE(bool)

440

441

442

449

450

452

453

455

456

457

459

460

461

463

464

465

466

467

468 using ExportDecl = llvm::PointerIntPair<Module *, 1, bool>;

469

470

472

473

474

476

478

479

481

482

483

484

486 };

487

488

490

491

493

494

496

497

498

500

501

502

507

508

509

510

511

513

514

516 };

517

518

519

521

522

523

525

526

527

529

530

538

539

540

542

543

551

552

554

555

558 unsigned VisibilityID);

559

561

562

564

565

566

567

568

569

570

571

572

573

574

575

576

577

580

581

583

584

585

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

607 Requirement &Req,

608 UnresolvedHeaderDirective &MissingHeader,

610

611

613

614

615

616

617

618

619

621

622

623

624

626 for (const Module *Mod = this; Mod; Mod = Mod->Parent)

627 if (Mod->IsFramework)

628 return true;

629

630 return false;

631 }

632

633

634

638

639

640

644 Parent->SubModules.push_back(this);

645 }

646

647

651

652

657

658

662

663

667

668

670

674

675

679

683

685

686

688

689

690

691

692

693

695 return "";

696

698 auto pos = Name.find(':');

699 return StringRef(Name.data(), pos);

700 }

701

704

706 }

707

708

709

710

711

712 std::string getFullModuleName(bool AllowStringLiterals = false) const;

713

714

715

716

717

719

720

721

723 return const_cast<Module *>(

724 const_cast<const Module *>(this)->getTopLevelModule());

725 }

726

727

728

730

731

735

736

740

741

746

747

749 if (const auto *Dir = std::get_if(&Umbrella))

752 return std::nullopt;

753 }

754

755

757 if (const auto *Hdr = std::get_if(&Umbrella))

759 *Hdr};

760 return std::nullopt;

761 }

762

763

764

765

767

768

770

771

773 TopHeaderNames.push_back(std::string(Filename));

774 }

775

776

778

779

780

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

800

801

803

804

805

806

808

809

810

811

812

814

815

816

817

818

820

821

822

823

824

825

826

828 if (VisibleModulesCache.empty())

829 buildVisibleModulesCache();

830 return VisibleModulesCache.count(M);

831 }

832

834

837

838 llvm::iterator_range<submodule_iterator> submodules() {

839 return llvm::make_range(SubModules.begin(), SubModules.end());

840 }

841 llvm::iterator_range<submodule_const_iterator> submodules() const {

842 return llvm::make_range(SubModules.begin(), SubModules.end());

843 }

844

845

846

847

848

850

852 return "";

853 }

854

855

856 void print(raw_ostream &OS, unsigned Indent = 0, bool Dump = false) const;

857

858

859 void dump() const;

860

861private:

862 void buildVisibleModulesCache() const;

863};

864

865

867public:

870 : ImportLocs(std::move(O.ImportLocs)), Generation(O.Generation ? 1 : 0) {

871 O.ImportLocs.clear();

872 ++O.Generation;

873 }

874

875

876

878 ImportLocs = std::move(O.ImportLocs);

879 O.ImportLocs.clear();

880 ++O.Generation;

881 ++Generation;

882 return *this;

883 }

884

885

886

888

889

893

894

900

901

902

904

905

906

907

910 StringRef Message)>;

911

912

917

918private:

919

920

921 std::vector ImportLocs;

922

923

924 unsigned Generation = 0;

925};

926

927}

928

929#endif

Defines interfaces for clang::DirectoryEntry and clang::DirectoryEntryRef.

Defines interfaces for clang::FileEntry and clang::FileEntryRef.

Defines the clang::SourceLocation class and associated facilities.

A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the Fil...

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

Implements support for file system lookup, file system caching, and directory search management.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

Required to construct a Module.

Definition Module.h:136

Describes a module or submodule.

Definition Module.h:144

StringRef getTopLevelModuleName() const

Retrieve the name of the top-level module.

Definition Module.h:732

void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)

Add the given feature requirement to the list of features required by this module.

unsigned IsExplicit

Whether this is an explicit submodule.

Definition Module.h:384

SmallVector< ExportDecl, 2 > Exports

The set of export declarations.

Definition Module.h:471

bool isForBuilding(const LangOptions &LangOpts) const

Determine whether this module can be built in this compilation.

std::variant< std::monostate, FileEntryRef, DirectoryEntryRef > Umbrella

The umbrella header or directory.

Definition Module.h:205

unsigned InferSubmodules

Whether we should infer submodules for this module based on the headers.

Definition Module.h:406

ArrayRef< Header > getAllHeaders() const

Definition Module.h:301

Module * findSubmodule(StringRef Name) const

Find the submodule with the given name.

bool directlyUses(const Module *Requested)

Determine whether this module has declared its intention to directly use another module.

bool isNamedModuleInterfaceHasInit() const

Definition Module.h:684

std::vector< std::string > ConfigMacros

The set of "configuration macros", which are macros that (intentionally) change how this module is bu...

Definition Module.h:528

SourceLocation InferredSubmoduleLoc

The location of the inferred submodule.

Definition Module.h:454

unsigned IsUnimportable

Whether this module has declared itself unimportable, either because it's missing a requirement from ...

Definition Module.h:361

bool isInterfaceOrPartition() const

Definition Module.h:671

NameVisibilityKind NameVisibility

The visibility of names within this particular module.

Definition Module.h:451

bool isModulePartitionImplementation() const

Is this a module partition implementation unit.

Definition Module.h:659

NameVisibilityKind

Describes the visibility of the various names within a particular module.

Definition Module.h:443

@ Hidden

All of the names in this module are hidden.

Definition Module.h:445

@ AllVisible

All of the names in this module are visible.

Definition Module.h:447

void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const

Print the module map for this module to the given stream.

bool isNamedModuleUnit() const

Is this a C++20 named module unit.

Definition Module.h:676

SourceLocation DefinitionLoc

The location of the module definition.

Definition Module.h:150

SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders

Headers that are mentioned in the module map file but could not be found on the file system.

Definition Module.h:341

Module(ModuleConstructorTag, StringRef Name, SourceLocation DefinitionLoc, Module *Parent, bool IsFramework, bool IsExplicit, unsigned VisibilityID)

Construct a new module or submodule.

Module * Parent

The parent of this module.

Definition Module.h:193

void markUnavailable(bool Unimportable)

Mark this module and all of its submodules as unavailable.

SmallVector< UnresolvedHeaderDirective, 1 > UnresolvedHeaders

Headers that are mentioned in the module map file but that we have not yet attempted to resolve to a ...

Definition Module.h:337

ModuleKind Kind

The kind of this module.

Definition Module.h:189

bool isPrivateModule() const

Definition Module.h:249

HeaderKind

Definition Module.h:278

@ HK_Textual

Definition Module.h:280

@ HK_Excluded

Definition Module.h:283

@ HK_PrivateTextual

Definition Module.h:282

@ HK_Private

Definition Module.h:281

@ HK_Normal

Definition Module.h:279

void addTopHeaderFilename(StringRef Filename)

Add a top-level header filename associated with this module.

Definition Module.h:772

bool isUnimportable() const

Determine whether this module has been declared unimportable.

Definition Module.h:563

bool fullModuleNameIs(ArrayRef< StringRef > nameParts) const

Whether the full name of this module is equal to joining nameParts with "."s.

Module * getPrivateModuleFragment() const

Get the Private Module Fragment (sub-module) for this module, it there is one.

void setASTFile(OptionalFileEntryRef File)

Set the serialized AST file for the top-level module of this module.

Definition Module.h:742

unsigned IsInferred

Whether this is an inferred submodule (module * { ... }).

Definition Module.h:399

llvm::SmallSetVector< Module *, 2 > Imports

The set of modules imported by this module, and on which this module depends.

Definition Module.h:458

bool isModuleVisible(const Module *M) const

Determine whether the specified module would be visible to a lookup at the end of this module.

Definition Module.h:827

unsigned IsSystem

Whether this is a "system" module (which assumes that all headers in it are system headers).

Definition Module.h:389

bool isModuleInterfaceUnit() const

Definition Module.h:680

static StringRef getModuleInputBufferName()

Definition Module.h:851

std::string Name

The name of this module.

Definition Module.h:147

Module * getGlobalModuleFragment() const

Get the Global Module Fragment (sub-module) for this module, it there is one.

bool isSubFramework() const

Determine whether this module is a subframework of another framework.

Definition Module.h:635

llvm::iterator_range< submodule_iterator > submodules()

Definition Module.h:838

unsigned IsExternC

Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "C"...

Definition Module.h:395

bool isModuleMapModule() const

Definition Module.h:251

unsigned ModuleMapIsPrivate

Whether this module came from a "private" module map, found next to a regular (public) module map.

Definition Module.h:434

llvm::SmallVector< LinkLibrary, 2 > LinkLibraries

The set of libraries or frameworks to link against when an entity from this module is used.

Definition Module.h:520

SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports

The set of export declarations that have yet to be resolved.

Definition Module.h:489

void addHeader(HeaderKind HK, Header H)

Definition Module.h:308

void setParent(Module *M)

Set the parent of this module.

Definition Module.h:641

std::optional< Header > getUmbrellaHeaderAsWritten() const

Retrieve the umbrella header as written.

Definition Module.h:756

unsigned getVisibilityID() const

Definition Module.h:833

SmallVector< Requirement, 2 > Requirements

The set of language features required to use this module.

Definition Module.h:352

bool isHeaderLikeModule() const

Is this module have similar semantics as headers.

Definition Module.h:648

bool isModuleImplementation() const

Is this a module implementation.

Definition Module.h:664

llvm::SmallSetVector< const Module *, 2 > UndeclaredUses

When NoUndeclaredIncludes is true, the set of modules this module tried to import but didn't because ...

Definition Module.h:499

std::string UmbrellaRelativeToRootModuleDirectory

Definition Module.h:214

OptionalDirectoryEntryRef Directory

The build directory of this module.

Definition Module.h:198

std::vector< Module * >::iterator submodule_iterator

Definition Module.h:835

llvm::iterator_range< submodule_const_iterator > submodules() const

Definition Module.h:841

SmallVector< ModuleId, 2 > UnresolvedDirectUses

The set of use declarations that have yet to be resolved.

Definition Module.h:495

unsigned NamedModuleHasInit

Whether this C++20 named modules doesn't need an initializer.

Definition Module.h:439

unsigned NoUndeclaredIncludes

Whether files in this module can only include non-modular headers and headers from used modules.

Definition Module.h:429

StringRef getPrimaryModuleInterfaceName() const

Get the primary module interface name from a partition.

Definition Module.h:687

bool isModulePartition() const

Is this a module partition.

Definition Module.h:653

llvm::SmallSetVector< Module *, 2 > AffectingClangModules

The set of top-level modules that affected the compilation of this module, but were not imported.

Definition Module.h:462

SmallVector< Module *, 2 > DirectUses

The directly used modules.

Definition Module.h:492

unsigned ConfigMacrosExhaustive

Whether the set of configuration macros is exhaustive.

Definition Module.h:424

std::string PresumedModuleMapFile

The presumed file name for the module map defining this module.

Definition Module.h:202

std::string APINotesFile

For the debug info, the path to this module's .apinotes file, if any.

Definition Module.h:221

ASTFileSignature Signature

The module signature.

Definition Module.h:208

bool isExplicitGlobalModule() const

Definition Module.h:242

ArrayRef< Header > getHeaders(HeaderKind HK) const

Definition Module.h:302

bool isGlobalModule() const

Does this Module scope describe a fragment of the global module within some C++ module.

Definition Module.h:239

unsigned InferExportWildcard

Whether, when inferring submodules, the inferr submodules should export all modules they import (e....

Definition Module.h:416

bool isSubModule() const

Determine whether this module is a submodule.

Definition Module.h:612

void getExportedModules(SmallVectorImpl< Module * > &Exported) const

Appends this module's list of exported modules to Exported.

std::vector< UnresolvedConflict > UnresolvedConflicts

The list of conflicts for which the module-id has not yet been resolved.

Definition Module.h:541

unsigned IsFromModuleFile

Whether this module was loaded from a module file.

Definition Module.h:376

bool isSubModuleOf(const Module *Other) const

Check if this module is a (possibly transitive) submodule of Other.

bool isPartOfFramework() const

Determine whether this module is a part of a framework, either because it is a framework module or be...

Definition Module.h:625

ArrayRef< FileEntryRef > getTopHeaders(FileManager &FileMgr)

The top-level headers associated with this module.

bool isAvailable() const

Determine whether this module is available for use within the current translation unit.

Definition Module.h:586

llvm::PointerIntPair< Module *, 1, bool > ExportDecl

Describes an exported module.

Definition Module.h:468

std::optional< DirectoryName > getUmbrellaDirAsWritten() const

Retrieve the umbrella directory as written.

Definition Module.h:748

unsigned HasIncompatibleModuleFile

Whether we tried and failed to load a module file for this module.

Definition Module.h:365

bool isImplicitGlobalModule() const

Definition Module.h:245

bool isHeaderUnit() const

Is this module a header unit.

Definition Module.h:669

ModuleKind

Definition Module.h:155

@ ModuleImplementationUnit

This is a C++20 module implementation unit.

Definition Module.h:167

@ ModuleMapModule

This is a module that was defined by a module map and built out of header files.

Definition Module.h:158

@ ImplicitGlobalModuleFragment

This is an implicit fragment of the global module which contains only language linkage declarations (...

Definition Module.h:185

@ ModulePartitionInterface

This is a C++20 module partition interface.

Definition Module.h:170

@ ModuleInterfaceUnit

This is a C++20 module interface unit.

Definition Module.h:164

@ ModuleHeaderUnit

This is a C++20 header unit.

Definition Module.h:161

@ ModulePartitionImplementation

This is a C++20 module partition implementation.

Definition Module.h:173

@ PrivateModuleFragment

This is the private module fragment within some C++ module.

Definition Module.h:180

@ ExplicitGlobalModuleFragment

This is the explicit Global Module Fragment of a modular TU.

Definition Module.h:177

void dump() const

Dump the contents of this module to the given output stream.

Module * ShadowingModule

A module with the same name that shadows this module.

Definition Module.h:355

unsigned IsFramework

Whether this is a framework module.

Definition Module.h:380

std::string ExportAsModule

The module through which entities defined in this module will eventually be exposed,...

Definition Module.h:218

std::string getFullModuleName(bool AllowStringLiterals=false) const

Retrieve the full name of this module, including the path from its top-level module.

bool isNamedModule() const

Does this Module is a named module of a standard named module?

Definition Module.h:224

std::string UmbrellaAsWritten

The name of the umbrella entry, as written in the module map.

Definition Module.h:211

void addTopHeader(FileEntryRef File)

Add a top-level header associated with this module.

std::vector< Module * >::const_iterator submodule_const_iterator

Definition Module.h:836

unsigned IsAvailable

Whether this module is available in the current translation unit.

Definition Module.h:372

unsigned InferExplicitSubmodules

Whether, when inferring submodules, the inferred submodules should be explicit.

Definition Module.h:411

Module * getTopLevelModule()

Retrieve the top-level module for this (sub)module, which may be this module.

Definition Module.h:722

OptionalFileEntryRef getASTFile() const

The serialized AST file for this module, if one was created.

Definition Module.h:737

OptionalDirectoryEntryRef getEffectiveUmbrellaDir() const

Get the effective umbrella directory for this module: either the one explicitly written in the module...

bool UseExportAsModuleLinkName

Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...

Definition Module.h:524

std::vector< Conflict > Conflicts

The list of conflicts.

Definition Module.h:553

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

Exposes information about the current target.

void setVisible(Module *M, SourceLocation Loc, bool IncludeExports=true, VisibleCallback Vis=[](Module *) {}, ConflictCallback Cb=[](ArrayRef< Module * >, Module *, StringRef) {})

Make a specific module visible.

VisibleModuleSet()=default

llvm::function_ref< void(Module *M)> VisibleCallback

A callback to call when a module is made visible (directly or indirectly) by a call to setVisible.

Definition Module.h:903

SourceLocation getImportLoc(const Module *M) const

Get the location at which the import of a module was triggered.

Definition Module.h:895

llvm::function_ref< void(ArrayRef< Module * > Path, Module *Conflict, StringRef Message)> ConflictCallback

A callback to call when a module conflict is found.

Definition Module.h:908

bool isVisible(const Module *M) const

Determine whether a module is visible.

Definition Module.h:890

unsigned getGeneration() const

Get the current visibility generation.

Definition Module.h:887

VisibleModuleSet & operator=(VisibleModuleSet &&O)

Move from another visible modules set.

Definition Module.h:877

VisibleModuleSet(VisibleModuleSet &&O)

Definition Module.h:869

The JSON file list parser is used to communicate input to InstallAPI.

CustomizableOptional< FileEntryRef > OptionalFileEntryRef

SmallVector< std::pair< std::string, SourceLocation >, 2 > ModuleId

Describes the name of a module.

Definition Module.h:55

raw_ostream & Indent(raw_ostream &Out, const unsigned int Space, bool IsDot)

@ Module

Module linkage, which indicates that the entity can be referred to from other translation units withi...

CustomizableOptional< DirectoryEntryRef > OptionalDirectoryEntryRef

@ Other

Other implicit parameter.

Diagnostic wrappers for TextAPI types for error reporting.

The signature of a module, which is a hash of the AST content.

Definition Module.h:58

uint64_t truncatedValue() const

Returns the value truncated to the size of an uint64_t.

Definition Module.h:73

static constexpr size_t size

Definition Module.h:61

static ASTFileSignature create(std::array< uint8_t, 20 > Bytes)

Definition Module.h:81

ASTFileSignature(BaseT S={{0}})

Definition Module.h:63

static ASTFileSignature createDummy()

Definition Module.h:91

std::array< uint8_t, 20 > BaseT

Definition Module.h:59

static ASTFileSignature createDISentinel()

Definition Module.h:85

static ASTFileSignature create(InputIt First, InputIt Last)

Definition Module.h:98

unsigned IsExternC

Whether this is an extern "C" module.

Definition Module.h:116

unsigned IsSystem

Whether this is a system module.

Definition Module.h:112

unsigned IsExhaustive

Whether this is an exhaustive set of configuration macros.

Definition Module.h:120

ModuleAttributes()

Definition Module.h:127

unsigned NoUndeclaredIncludes

Whether files in this module can only include non-modular headers and headers from used modules.

Definition Module.h:125

A conflict between two modules.

Definition Module.h:544

Module * Other

The module that this module conflicts with.

Definition Module.h:546

std::string Message

The message provided to the user when there is a conflict.

Definition Module.h:549

Information about a directory name as found in the module map file.

Definition Module.h:317

std::string PathRelativeToRootModuleDirectory

Definition Module.h:319

DirectoryEntryRef Entry

Definition Module.h:320

std::string NameAsWritten

Definition Module.h:318

bool IsFramework

Whether this is a framework rather than a library.

Definition Module.h:515

LinkLibrary(const std::string &Library, bool IsFramework)

Definition Module.h:505

std::string Library

The library to link against.

Definition Module.h:512

std::string FeatureName

Definition Module.h:344

bool RequiredState

Definition Module.h:345

An unresolved conflict with another module.

Definition Module.h:531

std::string Message

The message provided to the user when there is a conflict.

Definition Module.h:536

ModuleId Id

The (unresolved) module id.

Definition Module.h:533

Describes an exported module that has not yet been resolved (perhaps because the module it refers to ...

Definition Module.h:475

bool Wildcard

Whether this export declaration ends in a wildcard, indicating that all of its submodules should be e...

Definition Module.h:485

ModuleId Id

The name of the module.

Definition Module.h:480

SourceLocation ExportLoc

The location of the 'export' keyword in the module map file.

Definition Module.h:477