clang: lib/Serialization/ASTReaderDecl.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

58#include "llvm/ADT/DenseMap.h"

59#include "llvm/ADT/FoldingSet.h"

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

61#include "llvm/ADT/SmallPtrSet.h"

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

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

64#include "llvm/Bitstream/BitstreamReader.h"

65#include "llvm/Support/Casting.h"

66#include "llvm/Support/ErrorHandling.h"

67#include "llvm/Support/SaveAndRestore.h"

68#include

69#include

70#include

71#include

72#include

73#include

74

75using namespace clang;

76using namespace serialization;

77

78

79

80

81

82namespace {

83

84class RedeclarableResult {

85 Decl *MergeWith;

87 bool IsKeyDecl;

88

89public:

90 RedeclarableResult(Decl *MergeWith, GlobalDeclID FirstID, bool IsKeyDecl)

91 : MergeWith(MergeWith), FirstID(FirstID), IsKeyDecl(IsKeyDecl) {}

92

93

94 GlobalDeclID getFirstID() const { return FirstID; }

95

96

97 bool isKeyDecl() const { return IsKeyDecl; }

98

99

100

101 Decl *getKnownMergeTarget() const { return MergeWith; }

102};

103}

104

108

109public:

111

113 unsigned Number);

114

115

116

117

118

119 template

122

123 template

125 RedeclarableResult &Redecl) {

127 D, Existing, Redecl.isKeyDecl() ? Redecl.getFirstID() : GlobalDeclID());

128 }

129

132

134 struct CXXRecordDecl::DefinitionData &&NewDD);

136 struct ObjCInterfaceDecl::DefinitionData &&NewDD);

138 struct ObjCProtocolDecl::DefinitionData &&NewDD);

139};

140}

141

142

143

144

145

151 ASTReader::RecordLocation Loc;

154

156

157 TypeID DeferredTypeID = 0;

158 unsigned AnonymousDeclNumber = 0;

161

162

163

164

165 bool IsDeclMarkedUsed = false;

166

167 uint64_t GetCurrentCursorOffset();

168

169 uint64_t ReadLocalOffset() {

170 uint64_t LocalOffset = Record.readInt();

171 assert(LocalOffset < Loc.Offset && "offset point after current record");

172 return LocalOffset ? Loc.Offset - LocalOffset : 0;

173 }

174

175 uint64_t ReadGlobalOffset() {

176 uint64_t Local = ReadLocalOffset();

177 return Local ? Record.getGlobalBitOffset(Local) : 0;

178 }

179

181

182 SourceRange readSourceRange() { return Record.readSourceRange(); }

183

185

187

188 std::string readString() { return Record.readString(); }

189

190 Decl *readDecl() { return Record.readDecl(); }

191

192 template T *readDeclAs() { return Record.readDeclAs<T>(); }

193

196 return 0;

197

198 return Record.getGlobalSubmoduleID(Record.readInt());

199 }

200

201 Module *readModule() { return Record.getSubmodule(readSubmoduleID()); }

202

204 Decl *LambdaContext = nullptr,

205 unsigned IndexInLambdaContext = 0);

206 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,

208 unsigned IndexInLambdaContext);

209 void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);

210 void ReadObjCDefinitionData(struct ObjCProtocolDecl::DefinitionData &Data);

211

213

218

219

220

221

222

225

226

227

228

229

230

231 class FindExistingResult {

235 bool AddResult = false;

236 unsigned AnonymousDeclNumber = 0;

238

239 public:

240 FindExistingResult(ASTReader &Reader) : Reader(Reader) {}

241

243 unsigned AnonymousDeclNumber,

245 : Reader(Reader), New(New), Existing(Existing), AddResult(true),

246 AnonymousDeclNumber(AnonymousDeclNumber),

247 TypedefNameForLinkage(TypedefNameForLinkage) {}

248

249 FindExistingResult(FindExistingResult &&Other)

250 : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),

251 AddResult(Other.AddResult),

252 AnonymousDeclNumber(Other.AnonymousDeclNumber),

253 TypedefNameForLinkage(Other.TypedefNameForLinkage) {

254 Other.AddResult = false;

255 }

256

257 FindExistingResult &operator=(FindExistingResult &&) = delete;

258 ~FindExistingResult();

259

260

261

262 void suppress() { AddResult = false; }

263

264 operator NamedDecl *() const { return Existing; }

265

266 template operator T *() const {

267 return dyn_cast_or_null(Existing);

268 }

269 };

270

273 FindExistingResult findExisting(NamedDecl *D);

274

275public:

277 ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID,

280 ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {}

281

282 template

286

287 template

292 Decl *Canon);

293

296

297 template

301

302 template

305

307 llvm::BitstreamCursor &DeclsCursor, bool IsPartial);

308

311

313

316 Cat->NextClassCategory = Next;

317 }

318

341 RedeclarableResult

343

344 void

347 }

348

351 RedeclarableResult

353

356 }

357

387 void

416

418 uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset,

419 uint64_t &TULocalOffset);

420

421 template

423

424 template

426

428 RedeclarableResult &Redecl);

429

431

433

435

436

457};

458}

459

460namespace {

461

462

463

464template class MergedRedeclIterator {

465 DeclT *Start = nullptr;

466 DeclT *Canonical = nullptr;

467 DeclT *Current = nullptr;

468

469public:

470 MergedRedeclIterator() = default;

471 MergedRedeclIterator(DeclT *Start) : Start(Start), Current(Start) {}

472

473 DeclT *operator*() { return Current; }

474

475 MergedRedeclIterator &operator++() {

476 if (Current->isFirstDecl()) {

477 Canonical = Current;

478 Current = Current->getMostRecentDecl();

479 } else

480 Current = Current->getPreviousDecl();

481

482

483

484

485

486 if (Current == Start || Current == Canonical)

487 Current = nullptr;

488 return *this;

489 }

490

491 friend bool operator!=(const MergedRedeclIterator &A,

492 const MergedRedeclIterator &B) {

493 return A.Current != B.Current;

494 }

495};

496

497}

498

499template

500static llvm::iterator_range<MergedRedeclIterator>

502 return llvm::make_range(MergedRedeclIterator(D),

503 MergedRedeclIterator());

504}

505

506uint64_t ASTDeclReader::GetCurrentCursorOffset() {

507 return Loc.F->DeclsCursor.GetCurrentBitNo() + Loc.F->GlobalBitOffset;

508}

509

511 if (Record.readInt()) {

512 Reader.DefinitionSource[FD] =

513 Loc.F->Kind == ModuleKind::MK_MainFile ||

515 }

516 if (auto *CD = dyn_cast(FD)) {

517 CD->setNumCtorInitializers(Record.readInt());

518 if (CD->getNumCtorInitializers())

519 CD->CtorInitializers = ReadGlobalOffset();

520 }

521

522 Reader.PendingBodies[FD] = GetCurrentCursorOffset();

523}

524

527

528

529

531 IsDeclMarkedUsed = false;

532

533 if (auto *DD = dyn_cast(D)) {

534 if (auto *TInfo = DD->getTypeSourceInfo())

535 Record.readTypeLoc(TInfo->getTypeLoc());

536 }

537

538 if (auto *TD = dyn_cast(D)) {

539

541

542

543

544 if (NamedDeclForTagDecl.isValid())

545 cast(D)->TypedefNameDeclOrQualifier =

546 cast(Reader.GetDecl(NamedDeclForTagDecl));

547 } else if (auto *ID = dyn_cast(D)) {

548

550 } else if (auto *FD = dyn_cast(D)) {

551

552 if (Record.readInt())

554 } else if (auto *VD = dyn_cast(D)) {

556 } else if (auto *FD = dyn_cast(D)) {

557 if (FD->hasInClassInitializer() && Record.readInt()) {

558 FD->setLazyInClassInitializer(LazyDeclStmtPtr(GetCurrentCursorOffset()));

559 }

560 }

561}

562

565 auto ModuleOwnership =

569 IsDeclMarkedUsed |= D->Used;

572 bool HasStandaloneLexicalDC = DeclBits.getNextBit();

573 bool HasAttrs = DeclBits.getNextBit();

577

579 isa<ParmVarDecl, ObjCTypeParamDecl>(D)) {

580

581

582

583

584

585

586 GlobalDeclID SemaDCIDForTemplateParmDecl = readDeclID();

587 GlobalDeclID LexicalDCIDForTemplateParmDecl =

588 HasStandaloneLexicalDC ? readDeclID() : GlobalDeclID();

589 if (LexicalDCIDForTemplateParmDecl.isInvalid())

590 LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;

591 Reader.addPendingDeclContextInfo(D,

592 SemaDCIDForTemplateParmDecl,

593 LexicalDCIDForTemplateParmDecl);

595 } else {

596 auto *SemaDC = readDeclAs();

597 auto *LexicalDC =

598 HasStandaloneLexicalDC ? readDeclAs() : nullptr;

599 if (!LexicalDC)

600 LexicalDC = SemaDC;

601

602

604 if (auto *RD = dyn_cast(SemaDC))

605 MergedSemaDC = getOrFakePrimaryClassDefinition(Reader, RD);

606 else

607 MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);

608

609

610 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,

612 }

614

615 if (HasAttrs) {

617 Record.readAttributes(Attrs);

618

619

620 D->setAttrsImpl(Attrs, Reader.getContext());

621 }

622

623

624

625 bool ModulePrivate =

627 if (unsigned SubmoduleID = readSubmoduleID()) {

628 switch (ModuleOwnership) {

631 break;

636 break;

637 }

638

640

642

643 if (ModulePrivate) {

644

645

647

648

650

653 else

654 Reader.HiddenNamesMap[Owner].push_back(D);

655 }

656 } else if (ModulePrivate) {

658 }

659}

660

665 std::string Arg = readString();

666 memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());

667 D->getTrailingObjects<char>()[Arg.size()] = '\0';

668}

669

673 std::string Name = readString();

674 memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());

675 D->getTrailingObjects<char>()[Name.size()] = '\0';

676

677 D->ValueStart = Name.size() + 1;

678 std::string Value = readString();

679 memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),

681 D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';

682}

683

685 llvm_unreachable("Translation units are not serialized");

686}

687

691 AnonymousDeclNumber = Record.readInt();

692}

693

697

698 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());

699}

700

705 if (Record.readInt()) {

708 } else

710

711

712

713

714 readDecl();

715 return Redecl;

716}

717

721}

722

725 if (auto *Template = readDeclAs())

726

728 else

730}

731

735

737

746

747 switch (TagDeclBits.getNextBits(2)) {

748 case 0:

749 break;

750 case 1: {

752 Record.readQualifierInfo(*Info);

753 TD->TypedefNameDeclOrQualifier = Info;

754 break;

755 }

756 case 2:

757 NamedDeclForTagDecl = readDeclID();

758 TypedefNameForLinkage = Record.readIdentifier();

759 break;

760 default:

761 llvm_unreachable("unexpected tag info kind");

762 }

763

764 if (!isa(TD))

766 return Redecl;

767}

768

773 else

776

778 ED->setNumPositiveBits(EnumDeclBits.getNextBits(8));

779 ED->setNumNegativeBits(EnumDeclBits.getNextBits(8));

783

784 ED->setHasODRHash(true);

785 ED->ODRHash = Record.readInt();

786

787

788

791 if (!OldDef) {

792

793

796 OldDef = D;

797 break;

798 }

799 }

800 }

801 if (OldDef) {

802 Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));

805

806

809 Reader.PendingEnumOdrMergeFailures[OldDef].push_back(ED);

810 } else {

811 OldDef = ED;

812 }

813 }

814

815 if (auto *InstED = readDeclAs()) {

818 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);

820 }

821}

822

824 RedeclarableResult Redecl = VisitTagDecl(RD);

825

842 return Redecl;

843}

844

847 RD->setODRHash(Record.readInt());

848

849

850

853 RecordDecl *&OldDef = Reader.RecordDefinitions[Canon];

854 if (!OldDef) {

855

856

859 OldDef = D;

860 break;

861 }

862 }

863 }

864 if (OldDef) {

865 Reader.MergedDeclContexts.insert(std::make_pair(RD, OldDef));

869 Reader.PendingRecordOdrMergeFailures[OldDef].push_back(RD);

870 } else {

871 OldDef = RD;

872 }

873 }

874}

875

878

879

880

881 if (isa<FunctionDecl, VarDecl>(VD))

882 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());

883 else

885}

886

889 if (Record.readInt())

893}

894

898 if (Record.readInt()) {

899 auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();

900 Record.readQualifierInfo(*Info);

901 Info->TrailingRequiresClause = Record.readExpr();

902 DD->DeclInfo = Info;

903 }

906 TSIType.isNull() ? nullptr

908}

909

912

914

917 break;

920 break;

922 auto *Template = readDeclAs();

923 Template->init(FD);

925 break;

926 }

928 auto *InstFD = readDeclAs();

931 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);

933 break;

934 }

936 auto *Template = readDeclAs();

938

939

941 Record.readTemplateArgumentList(TemplArgs, true);

942

943

945 bool HasTemplateArgumentsAsWritten = Record.readBool();

946 if (HasTemplateArgumentsAsWritten)

947 Record.readTemplateArgumentListInfo(TemplArgsWritten);

948

950

954

956 if (Record.readInt()) {

957 auto *FD = readDeclAs();

960

963 }

964

967 C, FD, Template, TSK, TemplArgList,

968 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr, POI,

969 MSInfo);

970 FD->TemplateOrSpecialization = FTInfo;

971

972 if (FD->isCanonicalDecl()) {

973

974

975 auto *CanonTemplate = readDeclAs();

976

977

978

979

980

981 llvm::FoldingSetNodeID ID;

983 void *InsertPos = nullptr;

986 CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);

987 if (InsertPos)

988 CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);

989 else {

991 "already deserialized this template specialization");

993 }

994 }

995 break;

996 }

998

1000 unsigned NumCandidates = Record.readInt();

1001 while (NumCandidates--)

1002 Candidates.addDecl(readDeclAs());

1003

1004

1006 bool HasTemplateArgumentsAsWritten = Record.readBool();

1007 if (HasTemplateArgumentsAsWritten)

1008 Record.readTemplateArgumentListInfo(TemplArgsWritten);

1009

1012 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr);

1013

1014

1015 break;

1016 }

1017 }

1018

1020

1021

1022

1028

1029

1031 Reader.PendingDeducedFunctionTypes.push_back({FD, DeferredTypeID});

1032 } else {

1034 }

1035 DeferredTypeID = 0;

1036

1039

1040

1041

1043

1050

1051

1052

1053 const bool Pure = FunctionDeclBits.getNextBit();

1070

1071 FD->EndRangeLoc = readSourceLocation();

1074

1075 FD->ODRHash = Record.readInt();

1076 FD->setHasODRHash(true);

1077

1079

1080

1081

1082 if (auto Info = Record.readInt()) {

1083 bool HasMessage = Info & 2;

1085 HasMessage ? cast(Record.readExpr()) : nullptr;

1086

1087 unsigned NumLookups = Record.readInt();

1089 for (unsigned I = 0; I != NumLookups; ++I) {

1093 }

1094

1097 Reader.getContext(), Lookups, DeletedMessage));

1098 }

1099 }

1100

1101 if (Existing)

1106

1107

1108 auto merge = [this, &Redecl, FD](auto &&F) {

1109 auto *Existing = cast_or_null(Redecl.getKnownMergeTarget());

1110 RedeclarableResult NewRedecl(Existing ? F(Existing) : nullptr,

1111 Redecl.getFirstID(), Redecl.isKeyDecl());

1113 };

1115 merge(

1117 else

1120 });

1121 } else

1123

1124

1125

1127

1128

1129 unsigned NumParams = Record.readInt();

1131 Params.reserve(NumParams);

1132 for (unsigned I = 0; I != NumParams; ++I)

1133 Params.push_back(readDeclAs());

1134 FD->setParams(Reader.getContext(), Params);

1135

1136

1137

1138

1139 if (FD->hasAttr()) {

1140 auto *SKEPAttr = FD->getAttr();

1142 const SYCLKernelInfo *SKI = C.findSYCLKernelInfo(SKEPAttr->getKernelName());

1143 if (SKI) {

1145 Reader.Diag(FD->getLocation(), diag::err_sycl_kernel_name_conflict);

1147 diag::note_previous_declaration);

1148 SKEPAttr->setInvalidAttr();

1149 }

1150 } else {

1151 C.registerSYCLEntryPointFunction(FD);

1152 }

1153 }

1154}

1155

1158 if (Record.readInt()) {

1159

1160

1161 Reader.PendingBodies[MD] = GetCurrentCursorOffset();

1162 }

1163 MD->setSelfDecl(readDeclAs());

1164 MD->setCmdDecl(readDeclAs());

1172

1177 readDeclAs());

1178

1185 MD->DeclEndLoc = readSourceLocation();

1186 unsigned NumParams = Record.readInt();

1188 Params.reserve(NumParams);

1189 for (unsigned I = 0; I != NumParams; ++I)

1190 Params.push_back(readDeclAs());

1191

1193 unsigned NumStoredSelLocs = Record.readInt();

1195 SelLocs.reserve(NumStoredSelLocs);

1196 for (unsigned i = 0; i != NumStoredSelLocs; ++i)

1197 SelLocs.push_back(readSourceLocation());

1198

1199 MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);

1200}

1201

1204

1205 D->Variance = Record.readInt();

1206 D->Index = Record.readInt();

1207 D->VarianceLoc = readSourceLocation();

1208 D->ColonLoc = readSourceLocation();

1209}

1210

1215}

1216

1218 unsigned numParams = Record.readInt();

1219 if (numParams == 0)

1220 return nullptr;

1221

1223 typeParams.reserve(numParams);

1224 for (unsigned i = 0; i != numParams; ++i) {

1225 auto *typeParam = readDeclAs();

1226 if (!typeParam)

1227 return nullptr;

1228

1229 typeParams.push_back(typeParam);

1230 }

1231

1234

1236 typeParams, rAngleLoc);

1237}

1238

1239void ASTDeclReader::ReadObjCDefinitionData(

1240 struct ObjCInterfaceDecl::DefinitionData &Data) {

1241

1242 Data.SuperClassTInfo = readTypeSourceInfo();

1243

1244 Data.EndLoc = readSourceLocation();

1245 Data.HasDesignatedInitializers = Record.readInt();

1247 Data.HasODRHash = true;

1248

1249

1250 unsigned NumProtocols = Record.readInt();

1252 Protocols.reserve(NumProtocols);

1253 for (unsigned I = 0; I != NumProtocols; ++I)

1254 Protocols.push_back(readDeclAs());

1256 ProtoLocs.reserve(NumProtocols);

1257 for (unsigned I = 0; I != NumProtocols; ++I)

1258 ProtoLocs.push_back(readSourceLocation());

1259 Data.ReferencedProtocols.set(Protocols.data(), NumProtocols, ProtoLocs.data(),

1261

1262

1263 NumProtocols = Record.readInt();

1264 Protocols.clear();

1265 Protocols.reserve(NumProtocols);

1266 for (unsigned I = 0; I != NumProtocols; ++I)

1267 Protocols.push_back(readDeclAs());

1268 Data.AllReferencedProtocols.set(Protocols.data(), NumProtocols,

1270}

1271

1273 ObjCInterfaceDecl *D, struct ObjCInterfaceDecl::DefinitionData &&NewDD) {

1274 struct ObjCInterfaceDecl::DefinitionData &DD = D->data();

1275 if (DD.Definition == NewDD.Definition)

1276 return;

1277

1278 Reader.MergedDeclContexts.insert(

1279 std::make_pair(NewDD.Definition, DD.Definition));

1281

1282 if (D->getODRHash() != NewDD.ODRHash)

1283 Reader.PendingObjCInterfaceOdrMergeFailures[DD.Definition].push_back(

1284 {NewDD.Definition, &NewDD});

1285}

1286

1290 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());

1292

1294 if (Record.readInt()) {

1295

1296 ID->allocateDefinitionData();

1297

1298 ReadObjCDefinitionData(ID->data());

1300 if (Canon->Data.getPointer()) {

1301

1302

1304 ID->Data = Canon->Data;

1305 } else {

1306

1307

1308 ID->getCanonicalDecl()->Data = ID->Data;

1309

1310

1311 ID->setIvarList(nullptr);

1312 }

1313

1314

1315 Reader.PendingDefinitions.insert(ID);

1316

1317

1318 Reader.ObjCClassesLoaded.push_back(ID);

1319 } else {

1320 ID->Data = ID->getCanonicalDecl()->Data;

1321 }

1322}

1323

1327

1329 bool synth = Record.readInt();

1331

1332

1334 return;

1335

1336

1337

1339 return;

1344 if (PrevIvar && PrevIvar != IVD) {

1345 auto *ParentExt = dyn_cast(IVD->getDeclContext());

1346 auto *PrevParentExt =

1347 dyn_cast(PrevIvar->getDeclContext());

1348 if (ParentExt && PrevParentExt) {

1349

1350

1351 Reader

1352 .PendingObjCExtensionIvarRedeclarations[std::make_pair(ParentExt,

1353 PrevParentExt)]

1354 .push_back(std::make_pair(IVD, PrevIvar));

1355 } else if (ParentExt || PrevParentExt) {

1356

1357

1358

1359 Reader.Diag(IVD->getLocation(), diag::err_duplicate_ivar_declaration)

1360 << II;

1361 Reader.Diag(PrevIvar->getLocation(), diag::note_previous_definition);

1362 }

1363 }

1364}

1365

1366void ASTDeclReader::ReadObjCDefinitionData(

1367 struct ObjCProtocolDecl::DefinitionData &Data) {

1368 unsigned NumProtoRefs = Record.readInt();

1370 ProtoRefs.reserve(NumProtoRefs);

1371 for (unsigned I = 0; I != NumProtoRefs; ++I)

1372 ProtoRefs.push_back(readDeclAs());

1374 ProtoLocs.reserve(NumProtoRefs);

1375 for (unsigned I = 0; I != NumProtoRefs; ++I)

1376 ProtoLocs.push_back(readSourceLocation());

1377 Data.ReferencedProtocols.set(ProtoRefs.data(), NumProtoRefs,

1378 ProtoLocs.data(), Reader.getContext());

1380 Data.HasODRHash = true;

1381}

1382

1384 ObjCProtocolDecl *D, struct ObjCProtocolDecl::DefinitionData &&NewDD) {

1385 struct ObjCProtocolDecl::DefinitionData &DD = D->data();

1386 if (DD.Definition == NewDD.Definition)

1387 return;

1388

1389 Reader.MergedDeclContexts.insert(

1390 std::make_pair(NewDD.Definition, DD.Definition));

1392

1393 if (D->getODRHash() != NewDD.ODRHash)

1394 Reader.PendingObjCProtocolOdrMergeFailures[DD.Definition].push_back(

1395 {NewDD.Definition, &NewDD});

1396}

1397

1402

1403 if (Record.readInt()) {

1404

1405 PD->allocateDefinitionData();

1406

1407 ReadObjCDefinitionData(PD->data());

1408

1410 if (Canon->Data.getPointer()) {

1411

1412

1414 PD->Data = Canon->Data;

1415 } else {

1416

1417

1419 }

1420

1421 Reader.PendingDefinitions.insert(PD);

1422 } else {

1424 }

1425}

1426

1429}

1430

1436

1437

1438

1439

1440 Reader.CategoriesDeserialized.insert(CD);

1441

1442 CD->ClassInterface = readDeclAs();

1444 unsigned NumProtoRefs = Record.readInt();

1446 ProtoRefs.reserve(NumProtoRefs);

1447 for (unsigned I = 0; I != NumProtoRefs; ++I)

1448 ProtoRefs.push_back(readDeclAs());

1450 ProtoLocs.reserve(NumProtoRefs);

1451 for (unsigned I = 0; I != NumProtoRefs; ++I)

1452 ProtoLocs.push_back(readSourceLocation());

1453 CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),

1455

1456

1457 if (NumProtoRefs > 0 && CD->ClassInterface && CD->IsClassExtension())

1461}

1462

1466}

1467

1470 D->setAtLoc(readSourceLocation());

1471 D->setLParenLoc(readSourceLocation());

1474 D->setType(T, TSI);

1476 D->setPropertyAttributesAsWritten(

1478 D->setPropertyImplementation(

1486 D->setGetterMethodDecl(readDeclAs());

1487 D->setSetterMethodDecl(readDeclAs());

1488 D->setPropertyIvarDecl(readDeclAs());

1489}

1490

1493 D->setClassInterface(readDeclAs());

1494}

1495

1498 D->CategoryNameLoc = readSourceLocation();

1499}

1500

1503 D->setSuperClass(readDeclAs());

1504 D->SuperLoc = readSourceLocation();

1505 D->setIvarLBraceLoc(readSourceLocation());

1506 D->setIvarRBraceLoc(readSourceLocation());

1507 D->setHasNonZeroConstructors(Record.readInt());

1508 D->setHasDestructors(Record.readInt());

1509 D->NumIvarInitializers = Record.readInt();

1510 if (D->NumIvarInitializers)

1511 D->IvarInitializers = ReadGlobalOffset();

1512}

1513

1516 D->setAtLoc(readSourceLocation());

1517 D->setPropertyDecl(readDeclAs());

1518 D->PropertyIvarDecl = readDeclAs();

1519 D->IvarLoc = readSourceLocation();

1520 D->setGetterMethodDecl(readDeclAs());

1521 D->setSetterMethodDecl(readDeclAs());

1522 D->setGetterCXXConstructor(Record.readExpr());

1523 D->setSetterCXXAssignment(Record.readExpr());

1524}

1525

1528 FD->Mutable = Record.readInt();

1529

1530 unsigned Bits = Record.readInt();

1531 FD->StorageKind = Bits >> 1;

1532 if (FD->StorageKind == FieldDecl::ISK_CapturedVLAType)

1534 cast(Record.readType().getTypePtr());

1535 else if (Bits & 1)

1537

1540 if (auto *Tmpl = readDeclAs())

1542 }

1544}

1545

1548 PD->GetterId = Record.readIdentifier();

1549 PD->SetterId = Record.readIdentifier();

1550}

1551

1554 D->PartVal.Part1 = Record.readInt();

1555 D->PartVal.Part2 = Record.readInt();

1556 D->PartVal.Part3 = Record.readInt();

1557 for (auto &C : D->PartVal.Part4And5)

1559

1560

1563}

1564

1568 D->Value = Record.readAPValue();

1569

1570

1572 Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D))

1574}

1575

1578 D->Value = Record.readAPValue();

1579

1580

1581

1583 Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D))

1585}

1586

1589

1590 FD->ChainingSize = Record.readInt();

1591 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");

1593

1594 for (unsigned I = 0; I != FD->ChainingSize; ++I)

1595 FD->Chaining[I] = readDeclAs();

1596

1598}

1599

1603

1606 bool DefGeneratedInModule = VarDeclBits.getNextBit();

1611 bool HasDeducedType = false;

1612 if (!isa(VD)) {

1618

1625

1627 HasDeducedType = VarDeclBits.getNextBit();

1630

1632 }

1633

1634

1635

1636

1637 if (HasDeducedType)

1638 Reader.PendingDeducedVarTypes.push_back({VD, DeferredTypeID});

1639 else

1641 DeferredTypeID = 0;

1642

1644

1645

1649

1650 if (DefGeneratedInModule) {

1651 Reader.DefinitionSource[VD] =

1652 Loc.F->Kind == ModuleKind::MK_MainFile ||

1654 }

1655

1656 if (VD->hasAttr()) {

1658 if (CopyExpr)

1660 }

1661

1662 enum VarKind {

1663 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization

1664 };

1665 switch ((VarKind)Record.readInt()) {

1666 case VarNotTemplate:

1667

1668

1669 if (!isa(VD) && !isa(VD) &&

1670 !isa(VD))

1672 break;

1673 case VarTemplate:

1674

1676 break;

1677 case StaticDataMemberSpecialization: {

1678 auto *Tmpl = readDeclAs();

1683 break;

1684 }

1685 }

1686

1687 return Redecl;

1688}

1689

1691 if (uint64_t Val = Record.readInt()) {

1700 }

1701

1702

1703

1704

1705 Eval->Value = GetCurrentCursorOffset();

1706 }

1707}

1708

1711}

1712

1715

1716 unsigned scopeIndex = Record.readInt();

1718 unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit();

1719 unsigned scopeDepth = ParmVarDeclBits.getNextBits(7);

1720 unsigned declQualifier = ParmVarDeclBits.getNextBits(7);

1721 if (isObjCMethodParam) {

1722 assert(scopeDepth == 0);

1724 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;

1725 } else {

1727 }

1729

1731 if (ParmVarDeclBits.getNextBit())

1733

1734 if (ParmVarDeclBits.getNextBit())

1735 PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation();

1736

1737

1738

1739}

1740

1743 auto **BDs = DD->getTrailingObjects<BindingDecl *>();

1744 for (unsigned I = 0; I != DD->NumBindings; ++I) {

1745 BDs[I] = readDeclAs();

1746 BDs[I]->setDecomposedDecl(DD);

1747 }

1748}

1749

1752 BD->Binding = Record.readExpr();

1753}

1754

1759}

1760

1763 D->Statement = Record.readStmt();

1764}

1765

1768 BD->setBody(cast_or_null(Record.readStmt()));

1770 unsigned NumParams = Record.readInt();

1772 Params.reserve(NumParams);

1773 for (unsigned I = 0; I != NumParams; ++I)

1774 Params.push_back(readDeclAs());

1776

1782

1783 bool capturesCXXThis = Record.readInt();

1784 unsigned numCaptures = Record.readInt();

1786 captures.reserve(numCaptures);

1787 for (unsigned i = 0; i != numCaptures; ++i) {

1788 auto *decl = readDeclAs();

1789 unsigned flags = Record.readInt();

1790 bool byRef = (flags & 1);

1791 bool nested = (flags & 2);

1792 Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);

1793

1795 }

1797}

1798

1800

1802 for (unsigned I = 0; I < D->NumParams; ++I)

1803 D->setParam(I, readDeclAs());

1804 D->setNothrow(Record.readInt() != 0);

1805 D->setBody(cast_or_null(Record.readStmt()));

1806}

1807

1810 unsigned ContextParamPos = Record.readInt();

1812

1813 for (unsigned I = 0; I < CD->NumParams; ++I) {

1814 if (I != ContextParamPos)

1815 CD->setParam(I, readDeclAs());

1816 else

1817 CD->setContextParam(I, readDeclAs());

1818 }

1819}

1820

1824 D->setExternLoc(readSourceLocation());

1825 D->setRBraceLoc(readSourceLocation());

1826}

1827

1830 D->RBraceLoc = readSourceLocation();

1831}

1832

1835 D->setLocStart(readSourceLocation());

1836}

1837

1841

1843 D->setInline(NamespaceDeclBits.getNextBit());

1844 D->setNested(NamespaceDeclBits.getNextBit());

1845 D->LocStart = readSourceLocation();

1846 D->RBraceLoc = readSourceLocation();

1847

1848

1849

1850

1851

1853 if (Redecl.getFirstID() == ThisDeclID)

1854 AnonNamespace = readDeclID();

1855

1857

1858 if (AnonNamespace.isValid()) {

1859

1860

1861

1862 auto *Anon = cast(Reader.GetDecl(AnonNamespace));

1863 if (.isModule())

1864 D->setAnonymousNamespace(Anon);

1865 }

1866}

1867

1870 uint64_t LexicalOffset = 0;

1871 uint64_t VisibleOffset = 0;

1872 uint64_t ModuleLocalOffset = 0;

1873 uint64_t TULocalOffset = 0;

1874 VisitDeclContext(D, LexicalOffset, VisibleOffset, ModuleLocalOffset,

1875 TULocalOffset);

1876 D->IsCBuffer = Record.readBool();

1877 D->KwLoc = readSourceLocation();

1878 D->LBraceLoc = readSourceLocation();

1879 D->RBraceLoc = readSourceLocation();

1880}

1881

1885 D->NamespaceLoc = readSourceLocation();

1886 D->IdentLoc = readSourceLocation();

1887 D->QualifierLoc = Record.readNestedNameSpecifierLoc();

1888 D->Namespace = readDeclAs();

1890}

1891

1894 D->setUsingLoc(readSourceLocation());

1895 D->QualifierLoc = Record.readNestedNameSpecifierLoc();

1896 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());

1897 D->FirstUsingShadow.setPointer(readDeclAs());

1898 D->setTypename(Record.readInt());

1899 if (auto *Pattern = readDeclAs())

1902}

1903

1906 D->setUsingLoc(readSourceLocation());

1907 D->setEnumLoc(readSourceLocation());

1908 D->setEnumType(Record.readTypeSourceInfo());

1909 D->FirstUsingShadow.setPointer(readDeclAs());

1910 if (auto *Pattern = readDeclAs())

1913}

1914

1917 D->InstantiatedFrom = readDeclAs();

1918 auto **Expansions = D->getTrailingObjects<NamedDecl *>();

1919 for (unsigned I = 0; I != D->NumExpansions; ++I)

1920 Expansions[I] = readDeclAs();

1922}

1923

1927 D->Underlying = readDeclAs();

1929 D->UsingOrNextShadow = readDeclAs();

1930 auto *Pattern = readDeclAs();

1931 if (Pattern)

1934}

1935

1939 D->NominatedBaseClassShadowDecl = readDeclAs();

1940 D->ConstructedBaseClassShadowDecl = readDeclAs();

1941 D->IsVirtual = Record.readInt();

1942}

1943

1946 D->UsingLoc = readSourceLocation();

1947 D->NamespaceLoc = readSourceLocation();

1948 D->QualifierLoc = Record.readNestedNameSpecifierLoc();

1949 D->NominatedNamespace = readDeclAs();

1950 D->CommonAncestor = readDeclAs();

1951}

1952

1955 D->setUsingLoc(readSourceLocation());

1956 D->QualifierLoc = Record.readNestedNameSpecifierLoc();

1957 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());

1958 D->EllipsisLoc = readSourceLocation();

1960}

1961

1965 D->TypenameLocation = readSourceLocation();

1966 D->QualifierLoc = Record.readNestedNameSpecifierLoc();

1967 D->EllipsisLoc = readSourceLocation();

1969}

1970

1974}

1975

1976void ASTDeclReader::ReadCXXDefinitionData(

1978 Decl *LambdaContext, unsigned IndexInLambdaContext) {

1979

1981

1982#define FIELD(Name, Width, Merge) \

1983 if (!CXXRecordDeclBits.canGetNextNBits(Width)) \

1984 CXXRecordDeclBits.updateValue(Record.readInt()); \

1985 Data.Name = CXXRecordDeclBits.getNextBits(Width);

1986

1987#include "clang/AST/CXXRecordDeclDefinitionBits.def"

1988#undef FIELD

1989

1990

1992 Data.HasODRHash = true;

1993

1994 if (Record.readInt()) {

1995 Reader.DefinitionSource[D] =

1996 Loc.F->Kind == ModuleKind::MK_MainFile ||

1998 }

1999

2000 Record.readUnresolvedSet(Data.Conversions);

2001 Data.ComputedVisibleConversions = Record.readInt();

2002 if (Data.ComputedVisibleConversions)

2003 Record.readUnresolvedSet(Data.VisibleConversions);

2004 assert(Data.Definition && "Data.Definition should be already set!");

2005

2006 if (.IsLambda) {

2007 assert(!LambdaContext && !IndexInLambdaContext &&

2008 "given lambda context for non-lambda");

2009

2011 if (Data.NumBases)

2012 Data.Bases = ReadGlobalOffset();

2013

2015 if (Data.NumVBases)

2016 Data.VBases = ReadGlobalOffset();

2017

2019 } else {

2021

2022 auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);

2023

2025 Lambda.DependencyKind = LambdaBits.getNextBits(2);

2026 Lambda.IsGenericLambda = LambdaBits.getNextBit();

2027 Lambda.CaptureDefault = LambdaBits.getNextBits(2);

2028 Lambda.NumCaptures = LambdaBits.getNextBits(15);

2029 Lambda.HasKnownInternalLinkage = LambdaBits.getNextBit();

2030

2031 Lambda.NumExplicitCaptures = Record.readInt();

2032 Lambda.ManglingNumber = Record.readInt();

2033 if (unsigned DeviceManglingNumber = Record.readInt())

2034 Reader.getContext().DeviceLambdaManglingNumbers[D] = DeviceManglingNumber;

2035 Lambda.IndexInContext = IndexInLambdaContext;

2036 Lambda.ContextDecl = LambdaContext;

2037 Capture *ToCapture = nullptr;

2038 if (Lambda.NumCaptures) {

2040 Lambda.NumCaptures);

2041 Lambda.AddCaptureList(Reader.getContext(), ToCapture);

2042 }

2043 Lambda.MethodTyInfo = readTypeSourceInfo();

2044 for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {

2047 bool IsImplicit = CaptureBits.getNextBit();

2049 static_cast<LambdaCaptureKind>(CaptureBits.getNextBits(3));

2050 switch (Kind) {

2054 new (ToCapture)

2056 ToCapture++;

2057 break;

2060 auto *Var = readDeclAs();

2062 new (ToCapture) Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);

2063 ToCapture++;

2064 break;

2065 }

2066 }

2067 }

2068}

2069

2071 CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {

2072 assert(D->DefinitionData &&

2073 "merging class definition into non-definition");

2074 auto &DD = *D->DefinitionData;

2075

2076 if (DD.Definition != MergeDD.Definition) {

2077

2078 Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,

2079 DD.Definition));

2080 Reader.PendingDefinitions.erase(MergeDD.Definition);

2081 MergeDD.Definition->demoteThisDefinitionToDeclaration();

2083 assert(!Reader.Lookups.contains(MergeDD.Definition) &&

2084 "already loaded pending lookups for merged definition");

2085 }

2086

2087 auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);

2088 if (PFDI != Reader.PendingFakeDefinitionData.end() &&

2089 PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {

2090

2091

2092 assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");

2093 PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;

2094

2095

2096

2097 auto *Def = DD.Definition;

2098 DD = std::move(MergeDD);

2099 DD.Definition = Def;

2100 return;

2101 }

2102

2103 bool DetectedOdrViolation = false;

2104

2105 #define FIELD(Name, Width, Merge) Merge(Name)

2106 #define MERGE_OR(Field) DD.Field |= MergeDD.Field;

2107 #define NO_MERGE(Field) \

2108 DetectedOdrViolation |= DD.Field != MergeDD.Field; \

2109 MERGE_OR(Field)

2110 #include "clang/AST/CXXRecordDeclDefinitionBits.def"

2112 #undef NO_MERGE

2113 #undef MERGE_OR

2114

2115 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)

2116 DetectedOdrViolation = true;

2117

2118

2119

2120

2121

2122 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {

2123 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);

2124 DD.ComputedVisibleConversions = true;

2125 }

2126

2127

2128

2129

2130 if (DD.IsLambda) {

2131 auto &Lambda1 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(DD);

2132 auto &Lambda2 = static_cast<CXXRecordDecl::LambdaDefinitionData &>(MergeDD);

2133 DetectedOdrViolation |= Lambda1.DependencyKind != Lambda2.DependencyKind;

2134 DetectedOdrViolation |= Lambda1.IsGenericLambda != Lambda2.IsGenericLambda;

2135 DetectedOdrViolation |= Lambda1.CaptureDefault != Lambda2.CaptureDefault;

2136 DetectedOdrViolation |= Lambda1.NumCaptures != Lambda2.NumCaptures;

2137 DetectedOdrViolation |=

2138 Lambda1.NumExplicitCaptures != Lambda2.NumExplicitCaptures;

2139 DetectedOdrViolation |=

2140 Lambda1.HasKnownInternalLinkage != Lambda2.HasKnownInternalLinkage;

2141 DetectedOdrViolation |= Lambda1.ManglingNumber != Lambda2.ManglingNumber;

2142

2143 if (Lambda1.NumCaptures && Lambda1.NumCaptures == Lambda2.NumCaptures) {

2144 for (unsigned I = 0, N = Lambda1.NumCaptures; I != N; ++I) {

2145 LambdaCapture &Cap1 = Lambda1.Captures.front()[I];

2146 LambdaCapture &Cap2 = Lambda2.Captures.front()[I];

2148 }

2149 Lambda1.AddCaptureList(Reader.getContext(), Lambda2.Captures.front());

2150 }

2151 }

2152

2153

2155 return;

2156

2157 if (D->getODRHash() != MergeDD.ODRHash) {

2158 DetectedOdrViolation = true;

2159 }

2160

2161 if (DetectedOdrViolation)

2162 Reader.PendingOdrMergeFailures[DD.Definition].push_back(

2163 {MergeDD.Definition, &MergeDD});

2164}

2165

2167 Decl *LambdaContext,

2168 unsigned IndexInLambdaContext) {

2169 struct CXXRecordDecl::DefinitionData *DD;

2171

2172

2173

2174 bool IsLambda = Record.readInt();

2175 assert(!(IsLambda && Update) &&

2176 "lambda definition should not be added by update record");

2177 if (IsLambda)

2178 DD = new (C) CXXRecordDecl::LambdaDefinitionData(

2180 else

2181 DD = new (C) struct CXXRecordDecl::DefinitionData(D);

2182

2184

2185

2186

2187 if (!Canon->DefinitionData)

2188 Canon->DefinitionData = DD;

2189 D->DefinitionData = Canon->DefinitionData;

2190 ReadCXXDefinitionData(*DD, D, LambdaContext, IndexInLambdaContext);

2191

2192

2193 D->setCompleteDefinition(true);

2194

2195

2196

2197

2198 if (Canon->DefinitionData != DD) {

2200 return;

2201 }

2202

2203

2204

2205

2206 if (Update || Canon != D)

2207 Reader.PendingDefinitions.insert(D);

2208}

2209

2212

2214

2215 enum CXXRecKind {

2216 CXXRecNotTemplate = 0,

2217 CXXRecTemplate,

2218 CXXRecMemberSpecialization,

2219 CXXLambda

2220 };

2221

2222 Decl *LambdaContext = nullptr;

2223 unsigned IndexInLambdaContext = 0;

2224

2225 switch ((CXXRecKind)Record.readInt()) {

2226 case CXXRecNotTemplate:

2227

2228 if (!isa(D))

2230 break;

2231 case CXXRecTemplate: {

2232

2233 auto *Template = readDeclAs();

2234 D->TemplateOrInstantiation = Template;

2235 if (!Template->getTemplatedDecl()) {

2236

2237

2238

2239

2240

2241

2242 DeferredTypeID = 0;

2243 }

2244 break;

2245 }

2246 case CXXRecMemberSpecialization: {

2247 auto *RD = readDeclAs();

2252 D->TemplateOrInstantiation = MSI;

2254 break;

2255 }

2256 case CXXLambda: {

2257 LambdaContext = readDecl();

2258 if (LambdaContext)

2259 IndexInLambdaContext = Record.readInt();

2260 if (LambdaContext)

2261 MergeImpl.mergeLambda(D, Redecl, *LambdaContext, IndexInLambdaContext);

2262 else

2263

2264

2266 break;

2267 }

2268 }

2269

2270 bool WasDefinition = Record.readInt();

2271 if (WasDefinition)

2272 ReadCXXRecordDefinition(D, false, LambdaContext,

2273 IndexInLambdaContext);

2274 else

2275

2277

2278

2279

2280 if (WasDefinition) {

2282 if (KeyFn.isValid() && D->isCompleteDefinition())

2283

2284

2285

2287 }

2288

2289 return Redecl;

2290}

2291

2293 D->setExplicitSpecifier(Record.readExplicitSpec());

2294 D->Ctor = readDeclAs();

2296 D->setDeductionCandidateKind(

2298}

2299

2302

2303 unsigned NumOverridenMethods = Record.readInt();

2305 while (NumOverridenMethods--) {

2306

2307

2308 if (auto *MD = readDeclAs())

2310 }

2311 } else {

2312

2313

2314 Record.skipInts(NumOverridenMethods);

2315 }

2316}

2317

2319

2320

2321 D->setExplicitSpecifier(Record.readExplicitSpec());

2322 if (D->isInheritingConstructor()) {

2323 auto *Shadow = readDeclAs();

2324 auto *Ctor = readDeclAs();

2327 }

2328

2330}

2331

2334

2335 if (auto *OperatorDelete = readDeclAs()) {

2337 auto *ThisArg = Record.readExpr();

2338

2339 if (!Canon->OperatorDelete) {

2340 Canon->OperatorDelete = OperatorDelete;

2341 Canon->OperatorDeleteThisArg = ThisArg;

2342 }

2343 }

2344}

2345

2347 D->setExplicitSpecifier(Record.readExplicitSpec());

2349}

2350

2353 D->ImportedModule = readModule();

2354 D->setImportComplete(Record.readInt());

2355 auto *StoredLocs = D->getTrailingObjects<SourceLocation>();

2356 for (unsigned I = 0, N = Record.back(); I != N; ++I)

2357 StoredLocs[I] = readSourceLocation();

2358 Record.skipInts(1);

2359}

2360

2363 D->setColonLoc(readSourceLocation());

2364}

2365

2368 if (Record.readInt())

2369 D->Friend = readDeclAs();

2370 else

2371 D->Friend = readTypeSourceInfo();

2372 for (unsigned i = 0; i != D->NumTPLists; ++i)

2374 Record.readTemplateParameterList();

2376 D->UnsupportedFriend = (Record.readInt() != 0);

2377 D->FriendLoc = readSourceLocation();

2378 D->EllipsisLoc = readSourceLocation();

2379}

2380

2383 unsigned NumParams = Record.readInt();

2384 D->NumParams = NumParams;

2386 for (unsigned i = 0; i != NumParams; ++i)

2387 D->Params[i] = Record.readTemplateParameterList();

2388 if (Record.readInt())

2389 D->Friend = readDeclAs();

2390 else

2391 D->Friend = readTypeSourceInfo();

2392 D->FriendLoc = readSourceLocation();

2393}

2394

2397

2398 assert(->TemplateParams && "TemplateParams already set!");

2399 D->TemplateParams = Record.readTemplateParameterList();

2400 D->init(readDeclAs());

2401}

2402

2405 D->ConstraintExpr = Record.readExpr();

2407}

2408

2411

2412

2415 for (unsigned I = 0; I < D->NumTemplateArgs; ++I)

2416 Args.push_back(Record.readTemplateArgument(true));

2417 D->setTemplateArguments(Args);

2418}

2419

2421}

2422

2424 llvm::BitstreamCursor &DeclsCursor,

2425 bool IsPartial) {

2426 uint64_t Offset = ReadLocalOffset();

2427 bool Failed =

2428 Reader.ReadSpecializations(M, DeclsCursor, Offset, D, IsPartial);

2429 (void)Failed;

2430 assert(!Failed);

2431}

2432

2433RedeclarableResult

2436

2437

2438

2440 if (!CanonD->Common) {

2442 Reader.PendingDefinitions.insert(CanonD);

2443 }

2444 D->Common = CanonD->Common;

2445

2446

2447

2448 if (ThisDeclID == Redecl.getFirstID()) {

2449 if (auto *RTD = readDeclAs()) {

2450 assert(RTD->getKind() == D->getKind() &&

2451 "InstantiatedFromMemberTemplate kind mismatch");

2452 D->setInstantiatedFromMemberTemplate(RTD);

2453 if (Record.readInt())

2454 D->setMemberSpecialization();

2455 }

2456 }

2457

2460

2461 return Redecl;

2462}

2463

2467

2468 if (ThisDeclID == Redecl.getFirstID()) {

2469

2470

2473 }

2474

2475 if (D->getTemplatedDecl()->TemplateOrInstantiation) {

2476

2477

2478

2480 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());

2481 }

2482}

2483

2485 llvm_unreachable("BuiltinTemplates are not serialized");

2486}

2487

2488

2489

2490

2494

2495 if (ThisDeclID == Redecl.getFirstID()) {

2496

2497

2500 }

2501}

2502

2506

2508 if (Decl *InstD = readDecl()) {

2509 if (auto *CTD = dyn_cast(InstD)) {

2510 D->SpecializedTemplate = CTD;

2511 } else {

2513 Record.readTemplateArgumentList(TemplArgs);

2516 auto *PS =

2518 SpecializedPartialSpecialization();

2519 PS->PartialSpecialization

2520 = cast(InstD);

2521 PS->TemplateArgs = ArgList;

2522 D->SpecializedTemplate = PS;

2523 }

2524 }

2525

2527 Record.readTemplateArgumentList(TemplArgs, true);

2529 D->PointOfInstantiation = readSourceLocation();

2531

2532 bool writtenAsCanonicalDecl = Record.readInt();

2533 if (writtenAsCanonicalDecl) {

2534 auto *CanonPattern = readDeclAs();

2535 if (D->isCanonicalDecl()) {

2536

2538 if (auto *Partial = dyn_cast(D)) {

2539 CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations

2540 .GetOrInsertNode(Partial);

2541 } else {

2542 CanonSpec =

2543 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);

2544 }

2545

2546 if (CanonSpec != D) {

2548

2549

2550

2551 if (auto *DDD = D->DefinitionData) {

2552 if (CanonSpec->DefinitionData)

2554 else

2555 CanonSpec->DefinitionData = D->DefinitionData;

2556 }

2557 D->DefinitionData = CanonSpec->DefinitionData;

2558 }

2559 }

2560 }

2561

2562

2563 if (Record.readBool()) {

2566 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();

2567 D->ExplicitInfo = ExplicitInfo;

2568 }

2569

2570 if (Record.readBool())

2571 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());

2572

2573 return Redecl;

2574}

2575

2578

2579

2581 D->TemplateParams = Params;

2582

2584

2585

2586 if (ThisDeclID == Redecl.getFirstID()) {

2587 D->InstantiatedFromMember.setPointer(

2588 readDeclAs());

2589 D->InstantiatedFromMember.setInt(Record.readInt());

2590 }

2591}

2592

2595

2596 if (ThisDeclID == Redecl.getFirstID()) {

2597

2599 }

2600}

2601

2602

2603

2604

2605

2606

2610 if (Decl *InstD = readDecl()) {

2611 if (auto *VTD = dyn_cast(InstD)) {

2612 D->SpecializedTemplate = VTD;

2613 } else {

2615 Record.readTemplateArgumentList(TemplArgs);

2617 C, TemplArgs);

2618 auto *PS =

2619 new (C)

2620 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();

2621 PS->PartialSpecialization =

2622 cast(InstD);

2623 PS->TemplateArgs = ArgList;

2624 D->SpecializedTemplate = PS;

2625 }

2626 }

2627

2628

2629 if (Record.readBool()) {

2632 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();

2633 D->ExplicitInfo = ExplicitInfo;

2634 }

2635

2636 if (Record.readBool())

2637 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());

2638

2640 Record.readTemplateArgumentList(TemplArgs, true);

2642 D->PointOfInstantiation = readSourceLocation();

2644 D->IsCompleteDefinition = Record.readInt();

2645

2647

2648 bool writtenAsCanonicalDecl = Record.readInt();

2649 if (writtenAsCanonicalDecl) {

2650 auto *CanonPattern = readDeclAs();

2651 if (D->isCanonicalDecl()) {

2653 if (auto *Partial = dyn_cast(D)) {

2654 CanonSpec = CanonPattern->getCommonPtr()

2655 ->PartialSpecializations.GetOrInsertNode(Partial);

2656 } else {

2657 CanonSpec =

2658 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);

2659 }

2660

2661 if (CanonSpec != D)

2663 }

2664 }

2665

2666 return Redecl;

2667}

2668

2669

2670

2671

2672

2673

2677 D->TemplateParams = Params;

2678

2680

2681

2682 if (ThisDeclID == Redecl.getFirstID()) {

2683 D->InstantiatedFromMember.setPointer(

2684 readDeclAs());

2685 D->InstantiatedFromMember.setInt(Record.readInt());

2686 }

2687}

2688

2691

2692 D->setDeclaredWithTypename(Record.readInt());

2693

2694 bool TypeConstraintInitialized = D->hasTypeConstraint() && Record.readBool();

2695 if (TypeConstraintInitialized) {

2697 if (Record.readBool())

2698 CR = Record.readConceptReference();

2699 Expr *ImmediatelyDeclaredConstraint = Record.readExpr();

2700

2701 D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint);

2702 if ((D->ExpandedParameterPack = Record.readInt()))

2703 D->NumExpanded = Record.readInt();

2704 }

2705

2706 if (Record.readInt())

2707 D->setDefaultArgument(Reader.getContext(),

2708 Record.readTemplateArgumentLoc());

2709}

2710

2713

2714 D->setDepth(Record.readInt());

2715 D->setPosition(Record.readInt());

2716 if (D->hasPlaceholderTypeConstraint())

2717 D->setPlaceholderTypeConstraint(Record.readExpr());

2718 if (D->isExpandedParameterPack()) {

2719 auto TypesAndInfos =

2720 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();

2721 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {

2722 new (&TypesAndInfos[I].first) QualType(Record.readType());

2723 TypesAndInfos[I].second = readTypeSourceInfo();

2724 }

2725 } else {

2726

2727 D->ParameterPack = Record.readInt();

2728 if (Record.readInt())

2729 D->setDefaultArgument(Reader.getContext(),

2730 Record.readTemplateArgumentLoc());

2731 }

2732}

2733

2736 D->setDeclaredWithTypename(Record.readBool());

2737

2738 D->setDepth(Record.readInt());

2739 D->setPosition(Record.readInt());

2740 if (D->isExpandedParameterPack()) {

2742 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();

2743 I != N; ++I)

2744 Data[I] = Record.readTemplateParameterList();

2745 } else {

2746

2747 D->ParameterPack = Record.readInt();

2748 if (Record.readInt())

2749 D->setDefaultArgument(Reader.getContext(),

2750 Record.readTemplateArgumentLoc());

2751 }

2752}

2753

2757}

2758

2761 D->AssertExprAndFailed.setPointer(Record.readExpr());

2762 D->AssertExprAndFailed.setInt(Record.readInt());

2763 D->Message = cast_or_null(Record.readExpr());

2764 D->RParenLoc = readSourceLocation();

2765}

2766

2769}

2770

2774 D->ExtendingDecl = readDeclAs();

2775 D->ExprWithTemporary = Record.readStmt();

2776 if (Record.readInt()) {

2779 }

2780 D->ManglingNumber = Record.readInt();

2782}

2783

2785 uint64_t &VisibleOffset,

2786 uint64_t &ModuleLocalOffset,

2787 uint64_t &TULocalOffset) {

2788 LexicalOffset = ReadLocalOffset();

2789 VisibleOffset = ReadLocalOffset();

2790 ModuleLocalOffset = ReadLocalOffset();

2791 TULocalOffset = ReadLocalOffset();

2792}

2793

2794template

2797 Decl *MergeWith = nullptr;

2798

2799 bool IsKeyDecl = ThisDeclID == FirstDeclID;

2800 bool IsFirstLocalDecl = false;

2801

2802 uint64_t RedeclOffset = 0;

2803

2804

2805

2807 FirstDeclID = ThisDeclID;

2808 IsKeyDecl = true;

2809 IsFirstLocalDecl = true;

2810 } else if (unsigned N = Record.readInt()) {

2811

2812

2813 IsKeyDecl = N == 1;

2814 IsFirstLocalDecl = true;

2815

2816

2817

2818

2819

2820

2821 for (unsigned I = 0; I != N - 1; ++I)

2822 MergeWith = readDecl();

2823

2824 RedeclOffset = ReadLocalOffset();

2825 } else {

2826

2827

2828 (void)readDecl();

2829 }

2830

2831 auto *FirstDecl = cast_or_null(Reader.GetDecl(FirstDeclID));

2832 if (FirstDecl != D) {

2833

2834

2835

2836

2839 }

2840

2841 auto *DAsT = static_cast<T *>(D);

2842

2843

2844

2845

2846

2847 if (IsFirstLocalDecl)

2848 Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));

2849

2850 return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);

2851}

2852

2853

2854

2855template

2857 RedeclarableResult &Redecl) {

2858

2860 return;

2861

2862

2864 return;

2865

2866 auto *D = static_cast<T *>(DBase);

2867

2868 if (auto *Existing = Redecl.getKnownMergeTarget())

2869

2871 else if (FindExistingResult ExistingRes = findExisting(D))

2872 if (T *Existing = ExistingRes)

2874}

2875

2876

2877

2878

2879

2880

2881

2883 Decl &Context, unsigned IndexInContext) {

2884

2886 return;

2887

2888

2890 return;

2891

2892 if (auto *Existing = Redecl.getKnownMergeTarget())

2893

2895

2896

2897

2898 NamedDecl *&Slot = Reader.LambdaDeclarationsForMerging[{

2899 Context.getCanonicalDecl(), IndexInContext}];

2900 if (Slot)

2902 else

2903 Slot = D;

2904}

2905

2907 RedeclarableResult &Redecl) {

2909

2910

2911

2913}

2914

2915

2916

2917

2920 llvm_unreachable("bad assert_cast");

2921}

2922

2923

2924

2927 bool IsKeyDecl) {

2928 auto *DPattern = D->getTemplatedDecl();

2930 RedeclarableResult Result(

2931 ExistingPattern,

2932 DPattern->getCanonicalDecl()->getGlobalID(), IsKeyDecl);

2933

2934 if (auto *DClass = dyn_cast(DPattern)) {

2935

2936

2937 auto *ExistingClass =

2938 cast(ExistingPattern)->getCanonicalDecl();

2939 if (auto *DDD = DClass->DefinitionData) {

2940 if (ExistingClass->DefinitionData) {

2942 } else {

2943 ExistingClass->DefinitionData = DClass->DefinitionData;

2944

2945

2946 Reader.PendingDefinitions.insert(DClass);

2947 }

2948 }

2949 DClass->DefinitionData = ExistingClass->DefinitionData;

2950

2951 return mergeRedeclarable(DClass, cast(ExistingPattern),

2953 }

2954 if (auto *DFunction = dyn_cast(DPattern))

2955 return mergeRedeclarable(DFunction, cast(ExistingPattern),

2957 if (auto *DVar = dyn_cast(DPattern))

2959 if (auto *DAlias = dyn_cast(DPattern))

2960 return mergeRedeclarable(DAlias, cast(ExistingPattern),

2962 llvm_unreachable("merged an unknown kind of redeclarable template");

2963}

2964

2965

2966

2967template

2970 auto *D = static_cast<T *>(DBase);

2971 T *ExistingCanon = Existing->getCanonicalDecl();

2973 if (ExistingCanon != DCanon) {

2974

2975

2976

2978 D->First = ExistingCanon;

2979 ExistingCanon->Used |= D->Used;

2980 D->Used = false;

2981

2982 bool IsKeyDecl = KeyDeclID.isValid();

2983

2984

2985 if (auto *DTemplate = dyn_cast(D))

2987 DTemplate, assert_cast<RedeclarableTemplateDecl *>(ExistingCanon),

2988 IsKeyDecl);

2989

2990

2991 if (IsKeyDecl)

2992 Reader.KeyDecls[ExistingCanon].push_back(KeyDeclID);

2993 }

2994}

2995

2996

2997

2998

2999

3000

3002 if (!ND)

3003 return false;

3004

3005 if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(ND))

3006 return true;

3007 return false;

3008}

3009

3010

3011

3013

3015 return;

3016

3018

3020 Reader.LETemporaryForMerging[std::make_pair(

3025 else

3027}

3028

3029

3030

3031

3032

3033template

3035

3037 return;

3038

3039

3040

3041

3042

3045 return;

3046

3047 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))

3048 if (T *Existing = ExistingRes)

3050 Existing->getCanonicalDecl());

3051}

3052

3054 Record.readOMPChildren(D->Data);

3056}

3057

3059 Record.readOMPChildren(D->Data);

3061}

3062

3064 Record.readOMPChildren(D->Data);

3066}

3067

3073 D->setCombinerData(In, Out);

3075 D->setCombiner(Combiner);

3078 D->setInitializerData(Orig, Priv);

3081 D->setInitializer(Init, IK);

3082 D->PrevDeclInScope = readDeclID().getRawValue();

3083}

3084

3086 Record.readOMPChildren(D->Data);

3088 D->VarName = Record.readDeclarationName();

3089 D->PrevDeclInScope = readDeclID().getRawValue();

3090}

3091

3094}

3095

3096

3097

3098

3099

3100namespace {

3101class AttrReader {

3103

3104public:

3106

3107 uint64_t readInt() {

3108 return Reader.readInt();

3109 }

3110

3111 bool readBool() { return Reader.readBool(); }

3112

3115 }

3116

3119 }

3120

3121 Expr *readExpr() { return Reader.readExpr(); }

3122

3123 Attr *readAttr() { return Reader.readAttr(); }

3124

3125 std::string readString() {

3127 }

3128

3131 }

3132

3135 }

3136

3137 VersionTuple readVersionTuple() {

3139 }

3140

3142

3143 template T *readDeclAs() { return Reader.readDeclAs<T>(); }

3144};

3145}

3146

3148 AttrReader Record(*this);

3149 auto V = Record.readInt();

3150 if ()

3151 return nullptr;

3152

3153 Attr *New = nullptr;

3154

3155

3156 auto Kind = static_cast<attr::Kind>(V - 1);

3158

3163 unsigned ParsedKind = Record.readInt();

3164 unsigned Syntax = Record.readInt();

3165 unsigned SpellingIndex = Record.readInt();

3166 bool IsAlignas = (ParsedKind == AttributeCommonInfo::AT_Aligned &&

3168 SpellingIndex == AlignedAttr::Keyword_alignas);

3169 bool IsRegularKeywordAttribute = Record.readBool();

3170

3174 IsAlignas, IsRegularKeywordAttribute});

3175

3176#include "clang/Serialization/AttrPCHRead.inc"

3177

3178 assert(New && "Unable to decode attribute?");

3179 return New;

3180}

3181

3182

3184 for (unsigned I = 0, E = readInt(); I != E; ++I)

3186 Attrs.push_back(A);

3187}

3188

3189

3190

3191

3192

3193

3194

3195

3196

3197

3198

3199inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {

3200 assert(!DeclsLoaded[Index] && "Decl loaded twice?");

3201 DeclsLoaded[Index] = D;

3202}

3203

3204

3205

3206

3207

3208

3209

3210bool ASTReader::isConsumerInterestedIn(Decl *D) {

3211

3212

3213

3214

3215

3220 return false;

3221 }

3222

3225 return true;

3229 if (const auto *Var = dyn_cast(D))

3230 return Var->isFileVarDecl() &&

3232 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));

3233 if (const auto *Func = dyn_cast(D))

3234 return Func->doesThisDeclarationHaveABody() || PendingBodies.count(D);

3235

3238 return true;

3239

3240 return false;

3241}

3242

3243

3244ASTReader::RecordLocation ASTReader::DeclCursorForID(GlobalDeclID ID,

3247 assert(M);

3248 unsigned LocalDeclIndex = ID.getLocalDeclIndex();

3252}

3253

3254ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {

3255 auto I = GlobalBitOffsetsMap.find(GlobalOffset);

3256

3257 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");

3258 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);

3259}

3260

3261uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {

3263}

3264

3266ASTDeclReader::getOrFakePrimaryClassDefinition(ASTReader &Reader,

3268

3269 auto *DD = RD->DefinitionData;

3270 if (!DD)

3272

3273

3274

3275

3276

3277 if (!DD) {

3278 DD = new (Reader.getContext()) struct CXXRecordDecl::DefinitionData(RD);

3280 RD->DefinitionData = DD;

3282

3283

3284 Reader.PendingFakeDefinitionData.insert(

3285 std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));

3286 }

3287

3288 return DD->Definition;

3289}

3290

3291

3292

3295 if (auto *ND = dyn_cast(DC))

3296 return ND->getFirstDecl();

3297

3298 if (auto *RD = dyn_cast(DC))

3299 return getOrFakePrimaryClassDefinition(Reader, RD);

3300

3301 if (auto *RD = dyn_cast(DC))

3303

3304 if (auto *ED = dyn_cast(DC))

3306

3307 if (auto *OID = dyn_cast(DC))

3309

3310

3311

3312 if (auto *TU = dyn_cast(DC))

3314

3315 return nullptr;

3316}

3317

3318ASTDeclReader::FindExistingResult::~FindExistingResult() {

3319

3320

3321 if (TypedefNameForLinkage) {

3323 Reader.ImportedTypedefNamesForLinkage.insert(

3324 std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));

3325 return;

3326 }

3327

3328 if (!AddResult || Existing)

3329 return;

3330

3334 setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),

3335 AnonymousDeclNumber, New);

3339 Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]

3340 .push_back(New);

3341 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {

3342

3343

3344 MergeDC->makeDeclVisibleInContextImpl(New, true);

3345 }

3346}

3347

3348

3349

3350

3352 bool IsTypedefNameForLinkage) {

3353 if (!IsTypedefNameForLinkage)

3355

3356

3357

3358

3359 if (Found->isFromASTFile())

3360 return nullptr;

3361

3362 if (auto *TND = dyn_cast(Found))

3363 return TND->getAnonDeclWithTypedefName(true);

3364

3365 return nullptr;

3366}

3367

3368

3369

3370

3372ASTDeclReader::getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC) {

3373

3374 if (auto *RD = dyn_cast(LexicalDC)) {

3376 return DD ? DD->Definition : nullptr;

3377 } else if (auto *OID = dyn_cast(LexicalDC)) {

3378 return OID->getCanonicalDecl()->getDefinition();

3379 }

3380

3381

3382

3383

3385 if (auto *FD = dyn_cast(D))

3386 if (FD->isThisDeclarationADefinition())

3387 return FD;

3388 if (auto *MD = dyn_cast(D))

3389 if (MD->isThisDeclarationADefinition())

3390 return MD;

3391 if (auto *RD = dyn_cast(D))

3393 return RD;

3394 }

3395

3396

3397 return nullptr;

3398}

3399

3400NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,

3402 unsigned Index) {

3403

3404

3406

3407

3408 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];

3411

3412

3413

3414 auto *PrimaryDC = getPrimaryDCForAnonymousDecl(DC);

3415 if (PrimaryDC && !cast(PrimaryDC)->isFromASTFile()) {

3417 if (Previous.size() == Number)

3419 else

3421 });

3422 }

3423

3425}

3426

3427void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,

3430 auto *CanonDC = cast(DC)->getCanonicalDecl();

3431

3432 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];

3433 if (Index >= Previous.size())

3437}

3438

3439ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {

3440 DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage

3441 : D->getDeclName();

3442

3444

3445

3446 FindExistingResult Result(Reader, D, nullptr,

3447 AnonymousDeclNumber, TypedefNameForLinkage);

3450 }

3451

3454 if (TypedefNameForLinkage) {

3455 auto It = Reader.ImportedTypedefNamesForLinkage.find(

3456 std::make_pair(DC, TypedefNameForLinkage));

3457 if (It != Reader.ImportedTypedefNamesForLinkage.end())

3458 if (C.isSameEntity(It->second, D))

3459 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,

3460 TypedefNameForLinkage);

3461

3462

3463 }

3464

3466

3467

3468 if (auto *Existing = getAnonymousDeclForMerging(

3470 if (C.isSameEntity(Existing, D))

3471 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,

3472 TypedefNameForLinkage);

3476

3477

3478

3479 class UpToDateIdentifierRAII {

3481 bool WasOutToDate = false;

3482

3483 public:

3484 explicit UpToDateIdentifierRAII(IdentifierInfo *II) : II(II) {

3485 if (II) {

3487 if (WasOutToDate)

3489 }

3490 }

3491

3492 ~UpToDateIdentifierRAII() {

3493 if (WasOutToDate)

3495 }

3496 } UpToDate(Name.getAsIdentifierInfo());

3497

3499 IEnd = IdResolver.end();

3500 I != IEnd; ++I) {

3502 if (C.isSameEntity(Existing, D))

3503 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,

3504 TypedefNameForLinkage);

3505 }

3506 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {

3510 if (C.isSameEntity(Existing, D))

3511 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,

3512 TypedefNameForLinkage);

3513 }

3514 } else {

3515

3516 return FindExistingResult(Reader);

3517 }

3518

3519

3520

3521

3522

3523

3524

3525

3526

3528 if (MergedDCIt != Reader.MergedDeclContexts.end() &&

3531 Reader.PendingOdrMergeChecks.push_back(D);

3532

3533 return FindExistingResult(Reader, D, nullptr,

3534 AnonymousDeclNumber, TypedefNameForLinkage);

3535}

3536

3537template

3539 return D->RedeclLink.getLatestNotUpdated();

3540}

3541

3543 llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");

3544}

3545

3547 assert(D);

3548

3550#define ABSTRACT_DECL(TYPE)

3551#define DECL(TYPE, BASE) \

3552 case Decl::TYPE: \

3553 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));

3554#include "clang/AST/DeclNodes.inc"

3555 }

3556 llvm_unreachable("unknown decl kind");

3557}

3558

3559Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {

3561}

3562

3563namespace {

3567 const auto *IA = Previous->getAttr();

3568

3569 if (IA && ->hasAttr()) {

3570 NewAttr = cast(IA->clone(Context));

3573 }

3574

3575 const auto *AA = Previous->getAttr();

3576 if (AA && ->hasAttr()) {

3577 NewAttr = AA->clone(Context);

3580 }

3581}

3582}

3583

3584template

3588 D->RedeclLink.setPrevious(cast(Previous));

3589 D->First = cast(Previous)->First;

3590}

3591

3592namespace clang {

3593

3594template<>

3598 auto *VD = static_cast<VarDecl *>(D);

3599 auto *PrevVD = cast(Previous);

3600 D->RedeclLink.setPrevious(PrevVD);

3601 D->First = PrevVD->First;

3602

3603

3604

3605

3610 VD->demoteThisDefinitionToDeclaration();

3611 break;

3612 }

3613 }

3614 }

3615}

3616

3620}

3621

3622template<>

3627 auto *PrevFD = cast(Previous);

3628

3629 FD->RedeclLink.setPrevious(PrevFD);

3630 FD->First = PrevFD->First;

3631

3632

3633

3634 if (PrevFD->isInlined() != FD->isInlined()) {

3635

3636

3637

3638

3639

3640

3641

3642

3643

3644

3645

3646

3647

3648

3649

3650 FD->setImplicitlyInline(true);

3651 }

3652

3655 if (FPT && PrevFPT) {

3656

3657

3659 bool WasUnresolved =

3661 if (IsUnresolved != WasUnresolved)

3662 Reader.PendingExceptionSpecUpdates.insert(

3663 {Canon, IsUnresolved ? PrevFD : FD});

3664

3665

3666

3669 if (IsUndeduced != WasUndeduced)

3670 Reader.PendingDeducedTypeUpdates.insert(

3671 {cast(Canon),

3672 (IsUndeduced ? PrevFPT : FPT)->getReturnType()});

3673 }

3674}

3675

3676}

3677

3679 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");

3680}

3681

3682

3683

3684template

3686 Decl *ToD) {

3687 auto *To = cast(ToD);

3688 if (!From->hasDefaultArgument())

3689 return false;

3690 To->setInheritedDefaultArgument(Context, From);

3691 return true;

3692}

3693

3699 assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");

3700

3701 for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {

3702 NamedDecl *FromParam = FromTP->getParam(I);

3703 NamedDecl *ToParam = ToTP->getParam(I);

3704

3705 if (auto *FTTP = dyn_cast(FromParam))

3707 else if (auto *FNTTP = dyn_cast(FromParam))

3709 else

3711 Context, cast(FromParam), ToParam);

3712 }

3713}

3714

3715

3716

3717

3721

3722

3724 return;

3725

3726

3727

3728

3729 if (!isa<VarDecl, FunctionDecl, TagDecl, RedeclarableTemplateDecl>(Previous))

3730 return;

3731

3732

3733

3734

3735

3736

3737 if (isa(Previous))

3738 return;

3739 if (isa(Previous))

3740 return;

3741 if (auto *Func = dyn_cast(Previous);

3742 Func && Func->getTemplateSpecializationInfo())

3743 return;

3744

3746 if (!M)

3747 return;

3748

3749

3751

3753 return;

3754

3757 return;

3758

3759 Reader.PendingWarningForDuplicatedDefsInModuleUnits.push_back(

3761 return;

3762 }

3763

3764

3766 return;

3767

3769 diag::err_multiple_decl_in_different_modules)

3772}

3773

3777

3779#define ABSTRACT_DECL(TYPE)

3780#define DECL(TYPE, BASE) \

3781 case Decl::TYPE: \

3782 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \

3783 break;

3784#include "clang/AST/DeclNodes.inc"

3785 }

3786

3788

3789

3790

3791

3792

3793

3795 Previous->IdentifierNamespace &

3797

3798

3799

3800 if (auto *TD = dyn_cast(D))

3802 cast(Previous), TD);

3803

3804

3805

3806

3807

3808 mergeInheritableAttributes(Reader, D, Previous);

3809}

3810

3811template

3813 D->RedeclLink.setLatest(cast(Latest));

3814}

3815

3817 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");

3818}

3819

3821 assert(D && Latest);

3822

3824#define ABSTRACT_DECL(TYPE)

3825#define DECL(TYPE, BASE) \

3826 case Decl::TYPE: \

3827 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \

3828 break;

3829#include "clang/AST/DeclNodes.inc"

3830 }

3831}

3832

3833template

3835 D->RedeclLink.markIncomplete();

3836}

3837

3839 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");

3840}

3841

3842void ASTReader::markIncompleteDeclChain(Decl *D) {

3844#define ABSTRACT_DECL(TYPE)

3845#define DECL(TYPE, BASE) \

3846 case Decl::TYPE: \

3847 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \

3848 break;

3849#include "clang/AST/DeclNodes.inc"

3850 }

3851}

3852

3853

3856 RecordLocation Loc = DeclCursorForID(ID, DeclLoc);

3857 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;

3858

3859

3861

3862 ReadingKindTracker ReadingKind(Read_Decl, *this);

3863

3864

3865 Deserializing ADecl(this);

3866

3867 auto Fail = [](const char *what, llvm::Error &&Err) {

3868 llvm::report_fatal_error(Twine("ASTReader::readDeclRecord failed ") + what +

3869 ": " + toString(std::move(Err)));

3870 };

3871

3872 if (llvm::Error JumpFailed = DeclsCursor.JumpToBit(Loc.Offset))

3873 Fail("jumping", std::move(JumpFailed));

3877 if (!MaybeCode)

3878 Fail("reading code", MaybeCode.takeError());

3879 unsigned Code = MaybeCode.get();

3880

3882 Decl *D = nullptr;

3884 if (!MaybeDeclCode)

3885 llvm::report_fatal_error(

3886 Twine("ASTReader::readDeclRecord failed reading decl code: ") +

3887 toString(MaybeDeclCode.takeError()));

3888

3889 switch ((DeclCode)MaybeDeclCode.get()) {

3896 llvm_unreachable("Record cannot be de-serialized with readDeclRecord");

3899 break;

3902 break;

3905 break;

3908 break;

3911 break;

3914 break;

3917 break;

3920 break;

3923 break;

3926 break;

3929 break;

3932 break;

3935 break;

3938 break;

3941 break;

3944 break;

3947 break;

3950 break;

3953 break;

3956 break;

3959 break;

3962 break;

3965 break;

3968 break;

3971 break;

3974 break;

3977 break;

3980 break;

3983 break;

3986 break;

3989 break;

3992 break;

3995 break;

3998 break;

4001 break;

4004 break;

4006 bool HasTypeConstraint = Record.readInt();

4008 HasTypeConstraint);

4009 break;

4010 }

4012 bool HasTypeConstraint = Record.readInt();

4014 HasTypeConstraint);

4015 break;

4016 }

4018 bool HasTypeConstraint = Record.readInt();

4020 Context, ID, Record.readInt(), HasTypeConstraint);

4021 break;

4022 }

4025 break;

4029 break;

4032 break;

4035 break;

4038 break;

4041 break;

4044 break;

4047 break;

4050 break;

4053 break;

4056 break;

4059 break;

4062 break;

4065 break;

4068 break;

4071 break;

4074 break;

4077 break;

4080 break;

4083 break;

4086 break;

4089 break;

4092 break;

4095 break;

4098 break;

4101 break;

4104 break;

4107 break;

4109 D = MSGuidDecl::CreateDeserialized(Context, ID);

4110 break;

4112 D = UnnamedGlobalConstantDecl::CreateDeserialized(Context, ID);

4113 break;

4115 D = TemplateParamObjectDecl::CreateDeserialized(Context, ID);

4116 break;

4119 break;

4122 break;

4124 Error("attempt to read a C++ base-specifier record as a declaration");

4125 return nullptr;

4127 Error("attempt to read a C++ ctor initializer record as a declaration");

4128 return nullptr;

4130

4131

4133 break;

4136 unsigned NumChildren = Record.readInt();

4139 break;

4140 }

4142 unsigned NumClauses = Record.readInt();

4143 unsigned NumVars = Record.readInt();

4146 break;

4147 }

4149 unsigned NumClauses = Record.readInt();

4152 break;

4153 }

4156 break;

4158 unsigned NumClauses = Record.readInt();

4161 break;

4162 }

4165 break;

4168 break;

4172 break;

4175 break;

4178 break;

4181 break;

4184 break;

4188 break;

4189 }

4190

4191 assert(D && "Unknown declaration reading AST file");

4192 LoadedDecl(translateGlobalDeclIDToIndex(ID), D);

4193

4194

4195

4197

4198

4200

4201

4202

4203 if (auto *DC = dyn_cast(D)) {

4206 uint64_t ModuleLocalOffset = 0;

4208

4209 Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset, ModuleLocalOffset,

4210 TULocalOffset);

4211

4212

4213

4214

4215 if (!LexicalOffset && !VisibleOffset && !ModuleLocalOffset &&

4216 isa(D))

4217 if (auto Iter = DelayedNamespaceOffsetMap.find(ID);

4218 Iter != DelayedNamespaceOffsetMap.end()) {

4219 LexicalOffset = Iter->second.LexicalOffset;

4220 VisibleOffset = Iter->second.VisibleOffset;

4221 ModuleLocalOffset = Iter->second.ModuleLocalOffset;

4222 TULocalOffset = Iter->second.TULocalOffset;

4223 }

4224

4225 if (LexicalOffset &&

4226 ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, LexicalOffset, DC))

4227 return nullptr;

4228 if (VisibleOffset && ReadVisibleDeclContextStorage(

4229 *Loc.F, DeclsCursor, VisibleOffset, ID,

4230 VisibleDeclContextStorageKind::GenerallyVisible))

4231 return nullptr;

4232 if (ModuleLocalOffset &&

4233 ReadVisibleDeclContextStorage(

4234 *Loc.F, DeclsCursor, ModuleLocalOffset, ID,

4235 VisibleDeclContextStorageKind::ModuleLocalVisible))

4236 return nullptr;

4237 if (TULocalOffset && ReadVisibleDeclContextStorage(

4238 *Loc.F, DeclsCursor, TULocalOffset, ID,

4239 VisibleDeclContextStorageKind::TULocalVisible))

4240 return nullptr;

4241 }

4243

4244

4245 PendingUpdateRecords.push_back(

4246 PendingUpdateRecord(ID, D, true));

4247

4248

4249 if (auto *Class = dyn_cast(D))

4250

4251

4252 if (Class->isThisDeclarationADefinition() ||

4253 PendingDefinitions.count(Class))

4254 loadObjCCategories(ID, Class);

4255

4256

4257

4258

4259

4260 PotentiallyInterestingDecls.push_back(D);

4261

4262 return D;

4263}

4264

4265void ASTReader::PassInterestingDeclsToConsumer() {

4266 assert(Consumer);

4267

4268 if (PassingDeclsToConsumer)

4269 return;

4270

4271

4272

4273 SaveAndRestore GuardPassingDeclsToConsumer(PassingDeclsToConsumer, true);

4274

4275

4276

4277 for (auto ID : EagerlyDeserializedDecls)

4279 EagerlyDeserializedDecls.clear();

4280

4281 auto ConsumingPotentialInterestingDecls = [this]() {

4282 while (!PotentiallyInterestingDecls.empty()) {

4283 Decl *D = PotentiallyInterestingDecls.front();

4284 PotentiallyInterestingDecls.pop_front();

4285 if (isConsumerInterestedIn(D))

4286 PassInterestingDeclToConsumer(D);

4287 }

4288 };

4289 std::deque<Decl *> MaybeInterestingDecls =

4290 std::move(PotentiallyInterestingDecls);

4291 PotentiallyInterestingDecls.clear();

4292 assert(PotentiallyInterestingDecls.empty());

4293 while (!MaybeInterestingDecls.empty()) {

4294 Decl *D = MaybeInterestingDecls.front();

4295 MaybeInterestingDecls.pop_front();

4296

4297

4298

4299

4300

4301 if (auto *VD = dyn_cast(D);

4302 VD && VD->isFileVarDecl() && !VD->isExternallyVisible())

4303 VD->getInit();

4304 ConsumingPotentialInterestingDecls();

4305 if (isConsumerInterestedIn(D))

4306 PassInterestingDeclToConsumer(D);

4307 }

4308

4309

4310 ConsumingPotentialInterestingDecls();

4311

4313 auto *RD = cast(GetDecl(ID));

4315 PassVTableToConsumer(RD);

4316 }

4317 VTablesToEmit.clear();

4318}

4319

4320void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {

4321

4322

4323

4326 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);

4327 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);

4328

4329 if (UpdI != DeclUpdateOffsets.end()) {

4330 auto UpdateOffsets = std::move(UpdI->second);

4331 DeclUpdateOffsets.erase(UpdI);

4332

4333

4334

4335

4336

4337 bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);

4338 for (auto &FileAndOffset : UpdateOffsets) {

4339 ModuleFile *F = FileAndOffset.first;

4340 uint64_t Offset = FileAndOffset.second;

4343 if (llvm::Error JumpFailed = Cursor.JumpToBit(Offset))

4344

4345 llvm::report_fatal_error(

4346 Twine("ASTReader::loadDeclUpdateRecords failed jumping: ") +

4347 toString(std::move(JumpFailed)));

4349 if (!MaybeCode)

4350 llvm::report_fatal_error(

4351 Twine("ASTReader::loadDeclUpdateRecords failed reading code: ") +

4352 toString(MaybeCode.takeError()));

4353 unsigned Code = MaybeCode.get();

4356 assert(MaybeRecCode.get() == DECL_UPDATES &&

4357 "Expected DECL_UPDATES record!");

4358 else

4359 llvm::report_fatal_error(

4360 Twine("ASTReader::loadDeclUpdateRecords failed reading rec code: ") +

4361 toString(MaybeCode.takeError()));

4362

4365 Reader.UpdateDecl(D);

4366

4367

4368

4369 if (!WasInteresting && isConsumerInterestedIn(D)) {

4370 PotentiallyInterestingDecls.push_back(D);

4371 WasInteresting = true;

4372 }

4373 }

4374 }

4375

4376

4377 if (auto I = PendingVisibleUpdates.find(ID);

4378 I != PendingVisibleUpdates.end()) {

4379 auto VisibleUpdates = std::move(I->second);

4380 PendingVisibleUpdates.erase(I);

4381

4383 for (const auto &Update : VisibleUpdates)

4384 Lookups[DC].Table.add(

4388 }

4389

4390 if (auto I = PendingModuleLocalVisibleUpdates.find(ID);

4391 I != PendingModuleLocalVisibleUpdates.end()) {

4392 auto ModuleLocalVisibleUpdates = std::move(I->second);

4393 PendingModuleLocalVisibleUpdates.erase(I);

4394

4396 for (const auto &Update : ModuleLocalVisibleUpdates)

4397 ModuleLocalLookups[DC].Table.add(

4400

4401

4403 }

4404

4405 if (auto I = TULocalUpdates.find(ID); I != TULocalUpdates.end()) {

4406 auto Updates = std::move(I->second);

4407 TULocalUpdates.erase(I);

4408

4410 for (const auto &Update : Updates)

4411 TULocalLookups[DC].Table.add(

4415 }

4416

4417

4419 if (auto IT = RelatedDeclsMap.find(ID); IT != RelatedDeclsMap.end()) {

4420 for (auto LID : IT->second)

4422 RelatedDeclsMap.erase(IT);

4423 }

4424 }

4425

4426

4427 if (auto I = PendingSpecializationsUpdates.find(ID);

4428 I != PendingSpecializationsUpdates.end()) {

4429 auto SpecializationUpdates = std::move(I->second);

4430 PendingSpecializationsUpdates.erase(I);

4431

4432 for (const auto &Update : SpecializationUpdates)

4433 AddSpecializations(D, Update.Data, *Update.Mod, false);

4434 }

4435

4436

4437 if (auto I = PendingPartialSpecializationsUpdates.find(ID);

4438 I != PendingPartialSpecializationsUpdates.end()) {

4439 auto SpecializationUpdates = std::move(I->second);

4440 PendingPartialSpecializationsUpdates.erase(I);

4441

4442 for (const auto &Update : SpecializationUpdates)

4443 AddSpecializations(D, Update.Data, *Update.Mod, true);

4444 }

4445}

4446

4447void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {

4448

4450 if (FirstLocal != CanonDecl) {

4453 *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,

4454 CanonDecl);

4455 }

4456

4457 if (!LocalOffset) {

4459 return;

4460 }

4461

4462

4464 assert(M && "imported decl from no module file");

4465

4468 if (llvm::Error JumpFailed = Cursor.JumpToBit(LocalOffset))

4469 llvm::report_fatal_error(

4470 Twine("ASTReader::loadPendingDeclChain failed jumping: ") +

4471 toString(std::move(JumpFailed)));

4472

4475 if (!MaybeCode)

4476 llvm::report_fatal_error(

4477 Twine("ASTReader::loadPendingDeclChain failed reading code: ") +

4478 toString(MaybeCode.takeError()));

4479 unsigned Code = MaybeCode.get();

4482 "expected LOCAL_REDECLARATIONS record!");

4483 else

4484 llvm::report_fatal_error(

4485 Twine("ASTReader::loadPendingDeclChain failed reading rec code: ") +

4486 toString(MaybeCode.takeError()));

4487

4488

4489

4490 Decl *MostRecent = FirstLocal;

4491 for (unsigned I = 0, N = Record.size(); I != N; ++I) {

4492 unsigned Idx = N - I - 1;

4495 MostRecent = D;

4496 }

4498}

4499

4500namespace {

4501

4502

4503

4504 class ObjCCategoriesVisitor {

4507 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;

4509 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;

4511 unsigned PreviousGeneration;

4512

4514

4515 if (!Deserialized.erase(Cat))

4516 return;

4517

4518

4526 NonEquivalentDecls, StructuralEquivalenceKind::Default,

4527 false,

4528 false,

4529 true);

4530 if (!Ctx.IsEquivalent(Cat, Existing)) {

4531

4532 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)

4535 diag::note_previous_definition);

4536 }

4537 } else if (!Existing) {

4538

4539 Existing = Cat;

4540 }

4541 }

4542

4543

4544 if (Tail)

4546 else

4547 Interface->setCategoryListRaw(Cat);

4548 Tail = Cat;

4549 }

4550

4551 public:

4552 ObjCCategoriesVisitor(

4554 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,

4555 GlobalDeclID InterfaceID, unsigned PreviousGeneration)

4557 InterfaceID(InterfaceID), PreviousGeneration(PreviousGeneration) {

4558

4559 for (auto *Cat : Interface->known_categories()) {

4561 NameCategoryMap[Cat->getDeclName()] = Cat;

4562

4563

4564 Tail = Cat;

4565 }

4566 }

4567

4569

4570

4571 if (M.Generation <= PreviousGeneration)

4572 return true;

4573

4574

4575

4576

4580 return true;

4581

4582

4583

4588 Compare);

4590 LocalID != Result->getDefinitionID()) {

4591

4592

4593

4595 }

4596

4597

4598 unsigned Offset = Result->Offset;

4600 M.ObjCCategories[Offset++] = 0;

4601 for (unsigned I = 0; I != N; ++I)

4603 return true;

4604 }

4605 };

4606

4607}

4608

4610 unsigned PreviousGeneration) {

4611 ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,

4612 PreviousGeneration);

4613 ModuleMgr.visit(Visitor);

4614}

4615

4616template<typename DeclT, typename Fn>

4618 F(D);

4619

4620

4621

4622

4624 bool Found = false;

4625 for (auto *Redecl = MostRecent; Redecl && ;

4626 Redecl = Redecl->getPreviousDecl())

4627 Found = (Redecl == D);

4628

4629

4631 for (auto *Redecl = MostRecent; Redecl != D;

4633 F(Redecl);

4634 }

4635}

4636

4641 auto *RD = cast(D);

4643 assert(MD && "couldn't read decl from update record");

4644 Reader.PendingAddedClassMembers.push_back({RD, MD});

4645 break;

4646 }

4647

4649 auto *Anon = readDeclAs();

4650

4651

4652

4653

4654 if (.isModule()) {

4655 if (auto *TU = dyn_cast(D))

4656 TU->setAnonymousNamespace(Anon);

4657 else

4658 cast(D)->setAnonymousNamespace(Anon);

4659 }

4660 break;

4661 }

4662

4664 auto *VD = cast(D);

4665 VD->NonParmVarDeclBits.IsInline = Record.readInt();

4666 VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();

4668 break;

4669 }

4670

4673 if (auto *VTSD = dyn_cast(D)) {

4674 VTSD->setPointOfInstantiation(POI);

4675 } else if (auto *VD = dyn_cast(D)) {

4677 assert(MSInfo && "No member specialization information");

4679 } else {

4680 auto *FD = cast(D);

4681 if (auto *FTSInfo = FD->TemplateOrSpecialization

4683 FTSInfo->setPointOfInstantiation(POI);

4684 else

4685 cast<MemberSpecializationInfo *>(FD->TemplateOrSpecialization)

4686 ->setPointOfInstantiation(POI);

4687 }

4688 break;

4689 }

4690

4692 auto *Param = cast(D);

4693

4694

4695

4696

4697 auto *DefaultArg = Record.readExpr();

4698

4699

4700

4701 if (Param->hasUninstantiatedDefaultArg())

4702 Param->setDefaultArg(DefaultArg);

4703 break;

4704 }

4705

4707 auto *FD = cast(D);

4708 auto *DefaultInit = Record.readExpr();

4709

4710

4711

4712 if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {

4713 if (DefaultInit)

4714 FD->setInClassInitializer(DefaultInit);

4715 else

4716

4717

4718 FD->removeInClassInitializer();

4719 }

4720 break;

4721 }

4722

4724 auto *FD = cast(D);

4725 if (Reader.PendingBodies[FD]) {

4726

4727

4728 return;

4729 }

4730

4731 if (Record.readInt()) {

4732

4733

4734

4737 });

4738 }

4739 FD->setInnerLocStart(readSourceLocation());

4741 assert(Record.getIdx() == Record.size() && "lazy body must be last");

4742 break;

4743 }

4744

4746 auto *RD = cast(D);

4748 bool HadRealDefinition =

4749 OldDD && (OldDD->Definition != RD ||

4750 !Reader.PendingFakeDefinitionData.count(OldDD));

4754 ReadCXXRecordDefinition(RD, true);

4755

4756

4757 uint64_t LexicalOffset = ReadLocalOffset();

4758 if (!HadRealDefinition && LexicalOffset) {

4759 Record.readLexicalDeclContextStorage(LexicalOffset, RD);

4760 Reader.PendingFakeDefinitionData.erase(OldDD);

4761 }

4762

4767 MSInfo->setTemplateSpecializationKind(TSK);

4768 MSInfo->setPointOfInstantiation(POI);

4769 } else {

4770 auto *Spec = cast(RD);

4771 Spec->setTemplateSpecializationKind(TSK);

4772 Spec->setPointOfInstantiation(POI);

4773

4774 if (Record.readInt()) {

4775 auto *PartialSpec =

4776 readDeclAs();

4778 Record.readTemplateArgumentList(TemplArgs);

4781

4782

4783

4784 if (!isa<ClassTemplatePartialSpecializationDecl *>(

4785 Spec->getSpecializedTemplateOrPartial()))

4786 Spec->setInstantiationOf(PartialSpec, TemplArgList);

4787 }

4788 }

4789

4794

4795 if (Record.readInt()) {

4797 Record.readAttributes(Attrs);

4798

4799

4801 D->setAttrsImpl(Attrs, Reader.getContext());

4802 }

4803 break;

4804 }

4805

4807

4808

4809 auto *Del = readDeclAs();

4811 auto *ThisArg = Record.readExpr();

4812

4813 if (->OperatorDelete) {

4814 First->OperatorDelete = Del;

4815 First->OperatorDeleteThisArg = ThisArg;

4816 }

4817 break;

4818 }

4819

4822 auto ESI = Record.readExceptionSpecInfo(ExceptionStorage);

4823

4824

4825 auto *FD = cast(D);

4827

4828

4831 FPT->getReturnType(), FPT->getParamTypes(),

4832 FPT->getExtProtoInfo().withExceptionSpec(ESI)));

4833

4834

4835

4836 Reader.PendingExceptionSpecUpdates.insert(

4837 std::make_pair(FD->getCanonicalDecl(), FD));

4838 }

4839 break;

4840 }

4841

4843 auto *FD = cast(D);

4845 Reader.PendingDeducedTypeUpdates.insert(

4846 {FD->getCanonicalDecl(), DeducedResultType});

4847 break;

4848 }

4849

4851

4853 break;

4854

4858 break;

4859

4863 break;

4864

4866 D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),

4867 readSourceRange()));

4868 break;

4869

4871 auto AllocatorKind =

4872 static_castOMPAllocateDeclAttr::AllocatorTypeTy\(Record.readInt());

4873 Expr *Allocator = Record.readExpr();

4874 Expr *Alignment = Record.readExpr();

4876 D->addAttr(OMPAllocateDeclAttr::CreateImplicit(

4877 Reader.getContext(), AllocatorKind, Allocator, Alignment, SR));

4878 break;

4879 }

4880

4882 unsigned SubmoduleID = readSubmoduleID();

4883 auto *Exported = cast(D);

4886 Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);

4887 break;

4888 }

4889

4891 auto MapType = Record.readEnumOMPDeclareTargetDeclAttr::MapTypeTy();

4892 auto DevType = Record.readEnumOMPDeclareTargetDeclAttr::DevTypeTy();

4893 Expr *IndirectE = Record.readExpr();

4895 unsigned Level = Record.readInt();

4896 D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(

4898 readSourceRange()));

4899 break;

4900 }

4901

4904 Record.readAttributes(Attrs);

4905 assert(Attrs.size() == 1);

4907 break;

4908 }

4909 }

4910}

This file provides AST data structures related to concepts.

Defines the clang::ASTContext interface.

static T assert_cast(T t)

"Cast" to type T, asserting if we don't have an implicit conversion.

static bool allowODRLikeMergeInC(NamedDecl *ND)

ODR-like semantics for C/ObjC allow us to merge tag types and a structural check in Sema guarantees t...

static NamedDecl * getDeclForMerging(NamedDecl *Found, bool IsTypedefNameForLinkage)

Find the declaration that should be merged into, given the declaration found by name lookup.

static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From, Decl *ToD)

Inherit the default template argument from From to To.

static void inheritDefaultTemplateArguments(ASTContext &Context, TemplateDecl *From, TemplateDecl *To)

static void forAllLaterRedecls(DeclT *D, Fn F)

static llvm::iterator_range< MergedRedeclIterator< DeclT > > merged_redecls(DeclT *D)

Defines the clang::attr::Kind enum.

clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)

enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

This file defines OpenMP nodes for declarative directives.

Defines the C++ template declaration subclasses.

Defines the ExceptionSpecificationType enumeration and various utility functions.

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

Defines the LambdaCapture class.

Defines several types used to describe C++ lambda expressions that are shared between the parser and ...

Defines the clang::LangOptions interface.

llvm::MachO::Record Record

Defines the clang::Module class, which describes a module in the source code.

This file defines OpenMP AST classes for clauses.

static std::string toString(const clang::SanitizerSet &Sanitizers)

Produce a string containing comma-separated names of sanitizers in Sanitizers set.

Defines the clang::SourceLocation class and associated facilities.

Defines various enumerations that describe declaration and type specifiers.

Defines utilities for dealing with stack allocation and stack space.

C Language Family Type Representation.

__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)

APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...

bool needsCleanup() const

Returns whether the object performed allocations.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

TranslationUnitDecl * getTranslationUnitDecl() const

void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)

Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.

QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const

getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...

void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)

const LangOptions & getLangOpts() const

void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)

Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...

void setStaticLocalNumber(const VarDecl *VD, unsigned Number)

void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)

Note that the given C++ Method overrides the given Overridden method.

void setManglingNumber(const NamedDecl *ND, unsigned Number)

void * Allocate(size_t Size, unsigned Align=8) const

TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const

Allocate an uninitialized TypeSourceInfo.

void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())

Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...

QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const

Return a normal function type with a typed argument list.

void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)

void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)

Set the copy initialization expression of a block var decl.

void addDestruction(T *Ptr) const

If T isn't trivially destructible, calls AddDeallocation to register it for destruction.

ExternalASTSource * getExternalSource() const

Retrieve a pointer to the external AST source associated with this AST context, if any.

void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners=true)

Note that the definition ND has been merged into module M, and should be visible whenever M is visibl...

void setPrimaryMergedDecl(Decl *D, Decl *Primary)

void setObjCMethodRedeclaration(const ObjCMethodDecl *MD, const ObjCMethodDecl *Redecl)

bool isInSameModule(const Module *M1, const Module *M2)

If the two module M1 and M2 are in the same module.

void mergeTemplatePattern(RedeclarableTemplateDecl *D, RedeclarableTemplateDecl *Existing, bool IsKeyDecl)

Merge together the pattern declarations from two template declarations.

ASTDeclMerger(ASTReader &Reader)

void mergeRedeclarable(Redeclarable< T > *D, T *Existing, RedeclarableResult &Redecl)

void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl, Decl &Context, unsigned Number)

Attempt to merge D with a previous declaration of the same lambda, which is found by its index within...

void MergeDefinitionData(CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&NewDD)

void mergeRedeclarableImpl(Redeclarable< T > *D, T *Existing, GlobalDeclID KeyDeclID)

Attempts to merge the given declaration (D) with another declaration of the same entity.

void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D)

void VisitObjCImplementationDecl(ObjCImplementationDecl *D)

void mergeRedeclarableTemplate(RedeclarableTemplateDecl *D, RedeclarableResult &Redecl)

void VisitImportDecl(ImportDecl *D)

void VisitBindingDecl(BindingDecl *BD)

void VisitNamespaceDecl(NamespaceDecl *D)

void VisitTopLevelStmtDecl(TopLevelStmtDecl *D)

RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D)

void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)

void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D)

void ReadFunctionDefinition(FunctionDecl *FD)

void VisitLabelDecl(LabelDecl *LD)

void VisitObjCCategoryDecl(ObjCCategoryDecl *D)

void VisitUsingDirectiveDecl(UsingDirectiveDecl *D)

RedeclarableResult VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl *D)

void VisitFunctionDecl(FunctionDecl *FD)

void VisitObjCMethodDecl(ObjCMethodDecl *D)

void VisitUsingShadowDecl(UsingShadowDecl *D)

void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)

void VisitVarDecl(VarDecl *VD)

RedeclarableResult VisitRedeclarable(Redeclarable< T > *D)

void VisitMSGuidDecl(MSGuidDecl *D)

void VisitPragmaCommentDecl(PragmaCommentDecl *D)

void VisitRecordDecl(RecordDecl *RD)

void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D)

void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)

void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D)

void ReadVarDeclInit(VarDecl *VD)

static Decl * getMostRecentDeclImpl(Redeclarable< DeclT > *D)

void VisitNamespaceAliasDecl(NamespaceAliasDecl *D)

void VisitIndirectFieldDecl(IndirectFieldDecl *FD)

void VisitObjCContainerDecl(ObjCContainerDecl *D)

void VisitBlockDecl(BlockDecl *BD)

void VisitExportDecl(ExportDecl *D)

static void attachLatestDecl(Decl *D, Decl *latest)

void VisitStaticAssertDecl(StaticAssertDecl *D)

void VisitEmptyDecl(EmptyDecl *D)

void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D)

void VisitValueDecl(ValueDecl *VD)

void VisitEnumDecl(EnumDecl *ED)

void mergeRedeclarable(Redeclarable< T > *D, RedeclarableResult &Redecl)

Attempts to merge the given declaration (D) with another declaration of the same entity.

void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)

void VisitFriendTemplateDecl(FriendTemplateDecl *D)

void VisitObjCProtocolDecl(ObjCProtocolDecl *D)

void VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D)

void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)

void VisitDeclaratorDecl(DeclaratorDecl *DD)

RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD)

void VisitFriendDecl(FriendDecl *D)

void VisitLinkageSpecDecl(LinkageSpecDecl *D)

void VisitCXXRecordDecl(CXXRecordDecl *D)

ASTDeclReader(ASTReader &Reader, ASTRecordReader &Record, ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID, SourceLocation ThisDeclLoc)

void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD)

void VisitImplicitConceptSpecializationDecl(ImplicitConceptSpecializationDecl *D)

void VisitNamedDecl(NamedDecl *ND)

void mergeMergeable(Mergeable< T > *D)

Attempts to merge the given declaration (D) with another declaration of the same entity,...

void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D)

static Decl * getMostRecentDecl(Decl *D)

void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D)

void VisitCXXConstructorDecl(CXXConstructorDecl *D)

void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D)

void VisitImplicitParamDecl(ImplicitParamDecl *PD)

void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)

static void setNextObjCCategory(ObjCCategoryDecl *Cat, ObjCCategoryDecl *Next)

void VisitMSPropertyDecl(MSPropertyDecl *FD)

void VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)

void VisitFieldDecl(FieldDecl *FD)

RedeclarableResult VisitVarDeclImpl(VarDecl *D)

void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D)

void VisitCapturedDecl(CapturedDecl *CD)

void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)

void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)

RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D)

void VisitAccessSpecDecl(AccessSpecDecl *D)

void VisitCXXMethodDecl(CXXMethodDecl *D)

void VisitOMPAllocateDecl(OMPAllocateDecl *D)

void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)

static void attachLatestDeclImpl(Redeclarable< DeclT > *D, Decl *Latest)

static void markIncompleteDeclChainImpl(Redeclarable< DeclT > *D)

RedeclarableResult VisitTagDecl(TagDecl *TD)

ObjCTypeParamList * ReadObjCTypeParamList()

void VisitHLSLBufferDecl(HLSLBufferDecl *D)

void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D)

void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *GD)

void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D)

void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)

static void checkMultipleDefinitionInNamedModules(ASTReader &Reader, Decl *D, Decl *Previous)

void VisitUsingEnumDecl(UsingEnumDecl *D)

void VisitObjCImplDecl(ObjCImplDecl *D)

void VisitTranslationUnitDecl(TranslationUnitDecl *TU)

void VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset, uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset, uint64_t &TULocalOffset)

void VisitUnnamedGlobalConstantDecl(UnnamedGlobalConstantDecl *D)

void VisitTypeDecl(TypeDecl *TD)

void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)

void VisitEnumConstantDecl(EnumConstantDecl *ECD)

void VisitTypeAliasDecl(TypeAliasDecl *TD)

static void attachPreviousDeclImpl(ASTReader &Reader, Redeclarable< DeclT > *D, Decl *Previous, Decl *Canon)

void VisitConceptDecl(ConceptDecl *D)

void VisitObjCPropertyDecl(ObjCPropertyDecl *D)

void VisitOutlinedFunctionDecl(OutlinedFunctionDecl *D)

void VisitObjCIvarDecl(ObjCIvarDecl *D)

void VisitUsingPackDecl(UsingPackDecl *D)

void VisitFunctionTemplateDecl(FunctionTemplateDecl *D)

void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D)

RedeclarableResult VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D)

TODO: Unify with ClassTemplateSpecializationDecl version? May require unifying ClassTemplate(Partial)...

void VisitUsingDecl(UsingDecl *D)

void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D)

void VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D)

TODO: Unify with ClassTemplatePartialSpecializationDecl version? May require unifying ClassTemplate(P...

void VisitParmVarDecl(ParmVarDecl *PD)

void VisitVarTemplateDecl(VarTemplateDecl *D)

TODO: Unify with ClassTemplateDecl version? May require unifying ClassTemplateDecl and VarTemplateDec...

static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous, Decl *Canon)

void VisitClassTemplateDecl(ClassTemplateDecl *D)

void VisitCXXDestructorDecl(CXXDestructorDecl *D)

void VisitTemplateDecl(TemplateDecl *D)

void VisitCXXConversionDecl(CXXConversionDecl *D)

void VisitTypedefDecl(TypedefDecl *TD)

void VisitOMPRequiresDecl(OMPRequiresDecl *D)

RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD)

void VisitDecompositionDecl(DecompositionDecl *DD)

void ReadSpecializations(ModuleFile &M, Decl *D, llvm::BitstreamCursor &DeclsCursor, bool IsPartial)

Reads an AST files chain containing the contents of a translation unit.

bool isDeclIDFromModule(GlobalDeclID ID, ModuleFile &M) const

Returns true if global DeclID ID originated from module M.

DiagnosticBuilder Diag(unsigned DiagID) const

Report a diagnostic.

ASTContext & getContext()

Retrieve the AST context that this AST reader supplements.

Decl * ReadDecl(ModuleFile &F, const RecordDataImpl &R, unsigned &I)

Reads a declaration from the given position in a record in the given module.

ModuleFile * getOwningModuleFile(const Decl *D) const

Retrieve the module file that owns the given declaration, or NULL if the declaration is not from a mo...

T * ReadDeclAs(ModuleFile &F, const RecordDataImpl &R, unsigned &I)

Reads a declaration from the given position in a record in the given module.

SourceLocation ReadSourceLocation(ModuleFile &MF, RawLocEncoding Raw, LocSeq *Seq=nullptr) const

Read a source location from raw form.

LocalDeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, GlobalDeclID GlobalID)

Map a global declaration ID into the declaration ID used to refer to this declaration within the give...

QualType GetType(serialization::TypeID ID)

Resolve a type ID into a type, potentially building a new type.

IdentifierResolver & getIdResolver()

Get the identifier resolver used for name lookup / updates in the translation unit scope.

Decl * GetDecl(GlobalDeclID ID)

Resolve a declaration ID into a declaration, potentially building a new declaration.

Module * getSubmodule(serialization::SubmoduleID GlobalID)

Retrieve the submodule that corresponds to a global submodule ID.

void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)

Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...

void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)

SmallVector< uint64_t, 64 > RecordData

An object for streaming information from a record.

bool readBool()

Read a boolean value, advancing Idx.

std::string readString()

Read a string, advancing Idx.

void readAttributes(AttrVec &Attrs)

Reads attributes from the current stream position, advancing Idx.

T * readDeclAs()

Reads a declaration from the given position in the record, advancing Idx.

IdentifierInfo * readIdentifier()

ASTContext & getContext()

Retrieve the AST context that this AST reader supplements.

TypeSourceInfo * readTypeSourceInfo()

Reads a declarator info from the given record, advancing Idx.

SourceRange readSourceRange(LocSeq *Seq=nullptr)

Read a source range, advancing Idx.

OMPTraitInfo * readOMPTraitInfo()

Read an OMPTraitInfo object, advancing Idx.

VersionTuple readVersionTuple()

Read a version tuple, advancing Idx.

uint64_t readInt()

Returns the current value in this record, and advances to the next value.

Attr * readAttr()

Reads one attribute from the current stream position, advancing Idx.

Expr * readExpr()

Reads an expression.

SourceLocation readSourceLocation(LocSeq *Seq=nullptr)

Read a source location, advancing Idx.

Represents an access specifier followed by colon ':'.

static AccessSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Attr - This represents one attribute.

Attr * clone(ASTContext &C) const

Syntax

The style used to specify an attribute.

@ AS_Keyword

__ptr16, alignas(...), etc.

A binding in a decomposition declaration.

static BindingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

A simple helper class to unpack an integer to bits and consuming the bits in order.

uint32_t getNextBits(uint32_t Width)

A class which contains all the information about a particular captured value.

Represents a block literal declaration, which is like an unnamed FunctionDecl.

void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)

void setDoesNotEscape(bool B=true)

void setSignatureAsWritten(TypeSourceInfo *Sig)

void setCanAvoidCopyToHeap(bool B=true)

void setIsConversionFromLambda(bool val=true)

void setBlockMissingReturnType(bool val=true)

static BlockDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setIsVariadic(bool value)

void setBody(CompoundStmt *B)

void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)

Represents the builtin template declaration which is used to implement __make_integer_seq and other b...

Represents a C++ constructor within a class.

static CXXConstructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, uint64_t AllocKind)

Represents a C++ conversion function within a class.

static CXXConversionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a C++ deduction guide declaration.

static CXXDeductionGuideDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a C++ destructor within a class.

static CXXDestructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a static or instance method of a struct/union/class.

static CXXMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a C++ struct/union/class.

CXXRecordDecl * getDefinition() const

static CXXRecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this class is an instantiation of a member class of a class template specialization,...

CXXRecordDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

Represents the body of a CapturedStmt, and serves as its DeclContext.

static CapturedDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)

void setContextParam(unsigned i, ImplicitParamDecl *P)

void setNothrow(bool Nothrow=true)

void setParam(unsigned i, ImplicitParamDecl *P)

Declaration of a class template.

static ClassTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty class template node.

static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a class template specialization, which refers to a class template with a given set of temp...

static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Declaration of a C++20 concept.

static ConceptDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

A reference to a concept and its template args, as it appears in the code.

Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...

static ConstructorUsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)

The results of name lookup within a DeclContext.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

void setHasExternalVisibleStorage(bool ES=true) const

State whether this DeclContext has external storage for declarations visible in this context.

bool isTranslationUnit() const

DeclContext * getRedeclContext()

getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...

DeclContext * getPrimaryContext()

getPrimaryContext - There may be many different declarations of the same entity (including forward de...

bool isFunctionOrMethod() const

DeclID getRawValue() const

A simple visitor class that helps create declaration visitors.

Decl - This represents one declaration (or definition), e.g.

Decl * getPreviousDecl()

Retrieve the previous declaration that declares the same entity as this declaration,...

Decl * getMostRecentDecl()

Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...

ASTContext & getASTContext() const LLVM_READONLY

void setOwningModuleID(unsigned ID)

Set the owning module ID.

void setLocalExternDecl()

Changes the namespace of this declaration to reflect that it's a function-local extern declaration.

void setTopLevelDeclInObjCContainer(bool V=true)

void markUsed(ASTContext &C)

Mark the declaration used, in the sense of odr-use.

bool isCanonicalDecl() const

Whether this particular Decl is a canonical one.

Module * getOwningModule() const

Get the module that owns this declaration (for visibility purposes).

bool isFirstDecl() const

True if this is the first declaration in its redeclaration chain.

Module * getImportedOwningModule() const

Get the imported owning module, if this decl is from an imported (non-local) module.

ObjCDeclQualifier

ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...

bool isFromASTFile() const

Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...

bool isTemplateParameter() const

isTemplateParameter - Determines whether this declaration is a template parameter.

bool isInvalidDecl() const

unsigned FromASTFile

Whether this declaration was loaded from an AST file.

void setAccess(AccessSpecifier AS)

SourceLocation getLocation() const

IdentifierNamespace

IdentifierNamespace - The different namespaces in which declarations may appear.

@ IDNS_Ordinary

Ordinary names.

@ IDNS_Type

Types, declared with 'struct foo', typedefs, etc.

@ IDNS_Tag

Tags, declared with 'struct foo;' and referenced with 'struct foo'.

bool isTemplateParameterPack() const

isTemplateParameter - Determines whether this declaration is a template parameter pack.

void setImplicit(bool I=true)

void setReferenced(bool R=true)

void setLocation(SourceLocation L)

DeclContext * getDeclContext()

void setCachedLinkage(Linkage L) const

void setDeclContext(DeclContext *DC)

setDeclContext - Set both the semantic and lexical DeclContext to DC.

DeclContext * getLexicalDeclContext()

getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).

virtual Decl * getCanonicalDecl()

Retrieves the "canonical" declaration of the given declaration.

ModuleOwnershipKind

The kind of ownership a declaration has, for visibility purposes.

@ VisibleWhenImported

This declaration has an owning module, and is visible when that module is imported.

@ Unowned

This declaration is not owned by a module.

@ ReachableWhenImported

This declaration has an owning module, and is visible to lookups that occurs within that module.

@ ModulePrivate

This declaration has an owning module, but is only visible to lookups that occur within that module.

@ Visible

This declaration has an owning module, but is globally visible (typically because its owning module i...

void setModuleOwnershipKind(ModuleOwnershipKind MOK)

Set whether this declaration is hidden from name lookup.

bool shouldEmitInExternalSource() const

Whether the definition of the declaration should be emitted in external sources.

void setVisibleDespiteOwningModule()

Set that this declaration is globally visible, even if it came from a module that is not visible.

The name of a declaration.

Selector getObjCSelector() const

Get the Objective-C selector stored in this declaration name.

Represents a ValueDecl that came out of a declarator.

void setInnerLocStart(SourceLocation L)

void setTypeSourceInfo(TypeSourceInfo *TI)

TypeSourceInfo * getTypeSourceInfo() const

A decomposition declaration.

static DecompositionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumBindings)

Represents an empty-declaration.

static EmptyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

An instance of this object exists for each enum constant that is defined.

static EnumConstantDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setInitExpr(Expr *E)

void setInitVal(const ASTContext &C, const llvm::APSInt &V)

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this enumeration is an instantiation of a member enumeration of a class template specialization,...

void setFixed(bool Fixed=true)

True if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying type.

void setIntegerType(QualType T)

Set the underlying integer type.

void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)

Set the underlying integer type source info.

static EnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setScoped(bool Scoped=true)

True if this tag declaration is a scoped enumeration.

void setPromotionType(QualType T)

Set the promotion type.

EnumDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

void setScopedUsingClassTag(bool ScopedUCT=true)

If this tag declaration is a scoped enum, then this is true if the scoped enum was declared using the...

Represents a standard C++ module export declaration.

static ExportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

This represents one expression.

Represents a member of a struct/union/class.

void setBitWidth(Expr *Width)

Set the bit-field width for this member.

static FieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

const VariableArrayType * CapturedVLAType

void setRParenLoc(SourceLocation L)

void setAsmString(StringLiteral *Asm)

static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

FriendDecl - Represents the declaration of a friend entity, which can be a function,...

static FriendDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned FriendTypeNumTPLists)

Declaration of a friend template.

static FriendTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)

Represents a function declaration or definition.

void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)

FunctionTemplateDecl * getDescribedFunctionTemplate() const

Retrieves the function template that is described by this function declaration.

void setIsPureVirtual(bool P=true)

void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)

void setFriendConstraintRefersToEnclosingTemplate(bool V=true)

void setHasSkippedBody(bool Skipped=true)

static FunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setUsesSEHTry(bool UST)

void setIsMultiVersion(bool V=true)

Sets the multiversion state for this declaration and all of its redeclarations.

void setHasWrittenPrototype(bool P=true)

State that this function has a written prototype.

bool isExplicitlyDefaulted() const

Whether this function is explicitly defaulted.

MemberSpecializationInfo * getMemberSpecializationInfo() const

If this function is an instantiation of a member function of a class template specialization,...

FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const

If this function is actually a function template specialization, retrieve information about this func...

void setDefaultLoc(SourceLocation NewLoc)

void setInlineSpecified(bool I)

Set whether the "inline" keyword was specified for this function.

TemplatedKind

The kind of templated function a FunctionDecl can be.

@ TK_MemberSpecialization

@ TK_DependentNonTemplate

@ TK_FunctionTemplateSpecialization

@ TK_DependentFunctionTemplateSpecialization

TemplatedKind getTemplatedKind() const

What kind of templated function this is.

void setInstantiatedFromDecl(FunctionDecl *FD)

Specify that this function declaration was instantiated from a FunctionDecl FD.

bool isDeletedAsWritten() const

void setHasInheritedPrototype(bool P=true)

State that this function inherited its prototype from a previous declaration.

void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)

Specifies that this function declaration is actually a dependent function template specialization.

void setVirtualAsWritten(bool V)

State that this function is marked as virtual explicitly.

void setLateTemplateParsed(bool ILT=true)

State that this templated function will be late parsed.

void setImplicitlyInline(bool I=true)

Flag that this function is implicitly inline.

void setTrivialForCall(bool IT)

bool isDefaulted() const

Whether this function is defaulted.

void setIneligibleOrNotSelected(bool II)

void setConstexprKind(ConstexprSpecKind CSK)

void setDefaulted(bool D=true)

void setStorageClass(StorageClass SClass)

Sets the storage class as written in the source.

void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)

void setExplicitlyDefaulted(bool ED=true)

State that this function is explicitly defaulted.

void setHasImplicitReturnZero(bool IRZ)

State that falling off this function implicitly returns null/zero.

Represents a prototype with parameter type info, e.g.

ExceptionSpecificationType getExceptionSpecType() const

Get the kind of exception specification on this function.

Declaration of a template function.

static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty function template node.

Provides information about a function template specialization, which is a FunctionDecl that has been ...

static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)

void Profile(llvm::FoldingSetNodeID &ID)

FunctionDecl * getFunction() const

Retrieve the declaration of the function template specialization.

FunctionType - C99 6.7.5.3 - Function Declarators.

QualType getReturnType() const

HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.

static HLSLBufferDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

One of these records is kept for each identifier that is lexed.

void setOutOfDate(bool OOD)

Set whether the information for this identifier is out of date with respect to the external source.

bool isOutOfDate() const

Determine whether the information for this identifier is out of date with respect to the external sou...

iterator - Iterate over the decls of a specified declaration name.

IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.

iterator begin(DeclarationName Name)

Returns an iterator over decls with the name 'Name'.

bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)

Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...

iterator end()

Returns the end iterator.

static ImplicitConceptSpecializationDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID, unsigned NumTemplateArgs)

static ImplicitParamDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Describes a module import declaration, which makes the contents of the named module visible in the cu...

static ImportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumLocations)

Create a new, deserialized module import declaration.

Represents a field injected from an anonymous union/struct into the parent scope.

static IndirectFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setInherited(bool I)

Description of a constructor that was inherited from a base class.

Represents the declaration of a label.

static LabelDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Describes the capture of a variable or of this, or of a C++1y init-capture.

LambdaCaptureKind getCaptureKind() const

Determine the kind of capture.

Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...

unsigned getManglingNumber() const

static LifetimeExtendedTemporaryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ValueDecl * getExtendingDecl()

Represents a linkage specification.

static LinkageSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents the results of name lookup.

An instance of this class represents the declaration of a property member.

static MSPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Provides information a specialization of a member of a class template, which may be a member function...

void setPointOfInstantiation(SourceLocation POI)

Set the first point of instantiation.

Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...

Describes a module or submodule.

@ AllVisible

All of the names in this module are visible.

std::string Name

The name of this module.

bool isGlobalModule() const

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

@ ModuleMapModule

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

bool isNamedModule() const

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

Module * getTopLevelModule()

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

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

bool isPlaceholderVar(const LangOptions &LangOpts) const

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

void setDeclName(DeclarationName N)

Set the name of this declaration.

Represents a C++ namespace alias.

static NamespaceAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represent a C++ namespace.

static NamespaceDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.

static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, bool HasTypeConstraint)

This represents '#pragma omp allocate ...' directive.

static OMPAllocateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NVars, unsigned NClauses)

Pseudo declaration for capturing expressions.

static OMPCapturedExprDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

This represents '#pragma omp declare mapper ...' directive.

static OMPDeclareMapperDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)

Creates deserialized declare mapper node.

This represents '#pragma omp declare reduction ...' directive.

static OMPDeclareReductionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create deserialized declare reduction node.

This represents '#pragma omp requires...' directive.

static OMPRequiresDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)

Create deserialized requires node.

This represents '#pragma omp threadprivate ...' directive.

static OMPThreadPrivateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)

Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...

Represents a field declaration created by an @defs(...).

static ObjCAtDefsFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ObjCCategoryDecl - Represents a category declaration.

void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)

setProtocolList - Set the list of protocols that this interface implements.

static ObjCCategoryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setIvarLBraceLoc(SourceLocation Loc)

void setCategoryNameLoc(SourceLocation Loc)

void setIvarRBraceLoc(SourceLocation Loc)

bool IsClassExtension() const

ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.

static ObjCCategoryImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ObjCCompatibleAliasDecl - Represents alias of a class.

static ObjCCompatibleAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setClassInterface(ObjCInterfaceDecl *D)

ObjCContainerDecl - Represents a container for method declarations.

void setAtStartLoc(SourceLocation Loc)

void setAtEndRange(SourceRange atEnd)

ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...

static ObjCImplementationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents an ObjC class declaration.

void mergeClassExtensionProtocolList(ObjCProtocolDecl *const *List, unsigned Num, ASTContext &C)

mergeClassExtensionProtocolList - Merge class extension's protocol list into the protocol list for th...

ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)

static ObjCInterfaceDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)

ObjCInterfaceDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this Objective-C class.

ObjCIvarDecl - Represents an ObjC instance variable.

void setAccessControl(AccessControl ac)

void setNextIvar(ObjCIvarDecl *ivar)

ObjCInterfaceDecl * getContainingInterface()

Return the class interface that this ivar is logically contained in; this is either the interface whe...

void setSynthesize(bool synth)

static ObjCIvarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ObjCMethodDecl - Represents an instance or class method declaration.

void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub)

void setObjCDeclQualifier(ObjCDeclQualifier QV)

void setDefined(bool isDefined)

void setSelfDecl(ImplicitParamDecl *SD)

void setReturnTypeSourceInfo(TypeSourceInfo *TInfo)

void setHasRedeclaration(bool HRD) const

void setIsRedeclaration(bool RD)

void setCmdDecl(ImplicitParamDecl *CD)

bool hasRedeclaration() const

True if redeclared in the same interface.

void setRelatedResultType(bool RRT=true)

Note whether this method has a related result type.

void setOverriding(bool IsOver)

void setPropertyAccessor(bool isAccessor)

void setDeclImplementation(ObjCImplementationControl ic)

void setReturnType(QualType T)

static ObjCMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setHasSkippedBody(bool Skipped=true)

void setInstanceMethod(bool isInst)

void setVariadic(bool isVar)

Represents one property declaration in an Objective-C interface.

static ObjCPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...

static ObjCPropertyImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents an Objective-C protocol declaration.

static ObjCProtocolDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

ObjCProtocolDecl * getCanonicalDecl() override

Retrieves the canonical declaration of this Objective-C protocol.

Represents the declaration of an Objective-C type parameter.

static ObjCTypeParamDecl * CreateDeserialized(ASTContext &ctx, GlobalDeclID ID)

Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...

static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)

Create a new Objective-C type parameter list.

Represents a partial function definition.

static OutlinedFunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)

Represents a parameter to a function.

static ParmVarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setUninstantiatedDefaultArg(Expr *arg)

void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)

void setObjCMethodScopeInfo(unsigned parameterIndex)

Represents a #pragma detect_mismatch line.

static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NameValueSize)

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

const Type * getTypePtrOrNull() const

Represents a struct/union/class.

unsigned getODRHash()

Get precomputed ODRHash or add a new one.

void setAnonymousStructOrUnion(bool Anon)

void setArgPassingRestrictions(RecordArgPassingKind Kind)

void setNonTrivialToPrimitiveCopy(bool V)

void setHasNonTrivialToPrimitiveCopyCUnion(bool V)

void setHasNonTrivialToPrimitiveDestructCUnion(bool V)

void setHasFlexibleArrayMember(bool V)

void setParamDestroyedInCallee(bool V)

void setNonTrivialToPrimitiveDestroy(bool V)

void setHasObjectMember(bool val)

void setHasVolatileMember(bool val)

void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V)

static RecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)

void setHasUninitializedExplicitInitFields(bool V)

void setNonTrivialToPrimitiveDefaultInitialize(bool V)

Declaration of a redeclarable template.

CommonBase * Common

Pointer to the common data shared by all declarations of this template.

virtual CommonBase * newCommon(ASTContext &C) const =0

Provides common interface for the Decls that can be redeclared.

decl_type * getPreviousDecl()

Return the previous declaration of this declaration or NULL if this is the first declaration.

bool isFirstDecl() const

True if this is the first declaration in its redeclaration chain.

static DeclLink PreviousDeclLink(decl_type *D)

Represents the body of a requires-expression.

static RequiresExprBodyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

const FunctionDecl * getKernelEntryPointDecl() const

Encodes a location in the source.

A trivial tuple used to represent a source range.

Represents a C++11 static_assert declaration.

static StaticAssertDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

StringLiteral - This represents a string literal expression, e.g.

Represents the declaration of a struct/union/class/enum.

void setTagKind(TagKind TK)

void setCompleteDefinitionRequired(bool V=true)

True if this complete decl is required to be complete for some existing use.

void demoteThisDefinitionToDeclaration()

Mark a definition as a declaration and maintain information it was a definition.

bool isThisDeclarationADefinition() const

Return true if this declaration is a completion definition of the type.

void setEmbeddedInDeclarator(bool isInDeclarator)

True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...

bool isCompleteDefinition() const

Return true if this decl has its body fully specified.

TagDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

void setFreeStanding(bool isFreeStanding=true)

True if this tag is free standing, e.g. "struct foo;".

void setBraceRange(SourceRange R)

void setCompleteDefinition(bool V=true)

True if this decl has its body fully specified.

A convenient class for passing around template argument information.

A template argument list.

static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)

Create a new template argument list that copies the given set of template arguments.

The base class of all kinds of template declarations (e.g., class, function, etc.).

NamedDecl * getTemplatedDecl() const

Get the underlying, templated declaration.

TemplateParameterList * getTemplateParameters() const

Get the list of template parameters.

A template parameter object.

Stores a list of template parameters for a TemplateDecl and its derived classes.

TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.

static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Declaration of a template type parameter.

static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)

A declaration that models statements at global scope.

static TopLevelStmtDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

The top declaration context.

Represents the declaration of a typedef-name via a C++11 alias-declaration.

static TypeAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)

Declaration of an alias template.

static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty alias template node.

Represents a declaration of a type.

void setLocStart(SourceLocation L)

A container of type source information.

QualType getType() const

Return the type wrapped by this type source info.

const T * castAs() const

Member-template castAs.

AutoType * getContainedAutoType() const

Get the AutoType whose type will be deduced for a variable with an initializer of this type.

DeducedType * getContainedDeducedType() const

Get the DeducedType whose type will be deduced for a variable with an initializer of this type.

const T * getAs() const

Member-template getAs'.

Represents the declaration of a typedef-name via the 'typedef' type specifier.

static TypedefDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Base class for declarations which introduce a typedef-name.

void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)

void setTypeSourceInfo(TypeSourceInfo *newType)

An artificial decl, representing a global anonymous constant value which is uniquified by value withi...

void addDecl(NamedDecl *D)

A set of unresolved declarations.

This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...

static UnresolvedUsingIfExistsDecl * CreateDeserialized(ASTContext &Ctx, GlobalDeclID ID)

Represents a dependent using declaration which was marked with typename.

static UnresolvedUsingTypenameDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a dependent using declaration which was not marked with typename.

static UnresolvedUsingValueDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a C++ using-declaration.

static UsingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents C++ using-directive.

static UsingDirectiveDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a C++ using-enum-declaration.

static UsingEnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a pack of using declarations that a single using-declarator pack-expanded into.

static UsingPackDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumExpansions)

Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...

static UsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...

void setType(QualType newType)

Represents a variable declaration or definition.

ParmVarDeclBitfields ParmVarDeclBits

static VarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

VarDeclBitfields VarDeclBits

EvaluatedStmt * ensureEvaluatedStmt() const

Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...

NonParmVarDeclBitfields NonParmVarDeclBits

@ Definition

This declaration is definitely a definition.

void setDescribedVarTemplate(VarTemplateDecl *Template)

StorageClass getStorageClass() const

Returns the storage class as written in the source.

Declaration of a variable template.

static VarTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Create an empty variable template node.

static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Represents a variable template specialization, which refers to a variable template with a given set o...

static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)

Source location and bit offset of a declaration.

RawLocEncoding getRawLoc() const

uint64_t getBitOffset(const uint64_t DeclTypesBlockStartOffset) const

Information about a module that has been loaded by the ASTReader.

const serialization::ObjCCategoriesInfo * ObjCCategoriesMap

Array of category list location information within this module file, sorted by the definition ID.

unsigned LocalNumObjCCategoriesInMap

The number of redeclaration info entries in ObjCCategoriesMap.

llvm::BitstreamCursor DeclsCursor

DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.

uint64_t GlobalBitOffset

The global bit offset (or base) of this module.

const DeclOffset * DeclOffsets

Offset of each declaration within the bitstream, indexed by the declaration ID (-1).

unsigned Generation

The generation of which this module file is a part.

uint64_t DeclsBlockStartOffset

The offset to the start of the DECLTYPES_BLOCK block.

SmallVector< uint64_t, 1 > ObjCCategories

The Objective-C category lists for categories known to this module.

void visit(llvm::function_ref< bool(ModuleFile &M)> Visitor, llvm::SmallPtrSetImpl< ModuleFile * > *ModuleFilesHit=nullptr)

Visit each of the modules.

Class that performs name lookup into a DeclContext stored in an AST file.

const unsigned int LOCAL_REDECLARATIONS

Record code for a list of local redeclarations of a declaration.

DeclCode

Record codes for each kind of declaration.

const unsigned int DECL_UPDATES

Record of updates for a declaration that was modified after being deserialized.

@ DECL_EMPTY

An EmptyDecl record.

@ DECL_CAPTURED

A CapturedDecl record.

@ DECL_CXX_BASE_SPECIFIERS

A record containing CXXBaseSpecifiers.

@ DECL_CXX_RECORD

A CXXRecordDecl record.

@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION

A VarTemplatePartialSpecializationDecl record.

@ DECL_OMP_ALLOCATE

An OMPAllocateDcl record.

@ DECL_MS_PROPERTY

A MSPropertyDecl record.

@ DECL_OMP_DECLARE_MAPPER

An OMPDeclareMapperDecl record.

@ DECL_TOP_LEVEL_STMT_DECL

A TopLevelStmtDecl record.

@ DECL_REQUIRES_EXPR_BODY

A RequiresExprBodyDecl record.

@ DECL_STATIC_ASSERT

A StaticAssertDecl record.

@ DECL_INDIRECTFIELD

A IndirectFieldDecl record.

@ DECL_TEMPLATE_TEMPLATE_PARM

A TemplateTemplateParmDecl record.

@ DECL_IMPORT

An ImportDecl recording a module import.

@ DECL_UNNAMED_GLOBAL_CONSTANT

A UnnamedGlobalConstantDecl record.

@ DECL_ACCESS_SPEC

An AccessSpecDecl record.

@ DECL_OBJC_TYPE_PARAM

An ObjCTypeParamDecl record.

@ DECL_OBJC_CATEGORY_IMPL

A ObjCCategoryImplDecl record.

@ DECL_ENUM_CONSTANT

An EnumConstantDecl record.

@ DECL_PARM_VAR

A ParmVarDecl record.

@ DECL_TYPEDEF

A TypedefDecl record.

@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK

A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.

@ DECL_HLSL_BUFFER

A HLSLBufferDecl record.

@ DECL_NAMESPACE_ALIAS

A NamespaceAliasDecl record.

@ DECL_TYPEALIAS

A TypeAliasDecl record.

@ DECL_FUNCTION_TEMPLATE

A FunctionTemplateDecl record.

@ DECL_MS_GUID

A MSGuidDecl record.

@ DECL_UNRESOLVED_USING_TYPENAME

An UnresolvedUsingTypenameDecl record.

@ DECL_CLASS_TEMPLATE_SPECIALIZATION

A ClassTemplateSpecializationDecl record.

@ DECL_FILE_SCOPE_ASM

A FileScopeAsmDecl record.

@ DECL_PARTIAL_SPECIALIZATIONS

@ DECL_CXX_CONSTRUCTOR

A CXXConstructorDecl record.

@ DECL_CXX_CONVERSION

A CXXConversionDecl record.

@ DECL_FIELD

A FieldDecl record.

@ DECL_LINKAGE_SPEC

A LinkageSpecDecl record.

@ DECL_CONTEXT_TU_LOCAL_VISIBLE

A record that stores the set of declarations that are only visible to the TU.

@ DECL_NAMESPACE

A NamespaceDecl record.

@ DECL_NON_TYPE_TEMPLATE_PARM

A NonTypeTemplateParmDecl record.

@ DECL_USING_PACK

A UsingPackDecl record.

@ DECL_FUNCTION

A FunctionDecl record.

@ DECL_USING_DIRECTIVE

A UsingDirecitveDecl record.

@ DECL_RECORD

A RecordDecl record.

@ DECL_CONTEXT_LEXICAL

A record that stores the set of declarations that are lexically stored within a given DeclContext.

@ DECL_OUTLINEDFUNCTION

A OutlinedFunctionDecl record.

@ DECL_BLOCK

A BlockDecl record.

@ DECL_UNRESOLVED_USING_VALUE

An UnresolvedUsingValueDecl record.

@ DECL_TYPE_ALIAS_TEMPLATE

A TypeAliasTemplateDecl record.

@ DECL_CXX_CTOR_INITIALIZERS

A record containing CXXCtorInitializers.

@ DECL_OBJC_CATEGORY

A ObjCCategoryDecl record.

@ DECL_VAR

A VarDecl record.

@ DECL_UNRESOLVED_USING_IF_EXISTS

An UnresolvedUsingIfExistsDecl record.

@ DECL_USING

A UsingDecl record.

@ DECL_OBJC_PROTOCOL

A ObjCProtocolDecl record.

@ DECL_TEMPLATE_TYPE_PARM

A TemplateTypeParmDecl record.

@ DECL_VAR_TEMPLATE_SPECIALIZATION

A VarTemplateSpecializationDecl record.

@ DECL_OBJC_IMPLEMENTATION

A ObjCImplementationDecl record.

@ DECL_LABEL

A LabelDecl record.

@ DECL_OBJC_COMPATIBLE_ALIAS

A ObjCCompatibleAliasDecl record.

@ DECL_CONSTRUCTOR_USING_SHADOW

A ConstructorUsingShadowDecl record.

@ DECL_USING_ENUM

A UsingEnumDecl record.

@ DECL_FRIEND_TEMPLATE

A FriendTemplateDecl record.

@ DECL_PRAGMA_DETECT_MISMATCH

A PragmaDetectMismatchDecl record.

@ DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK

A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack.

@ DECL_OBJC_AT_DEFS_FIELD

A ObjCAtDefsFieldDecl record.

@ DECL_IMPLICIT_PARAM

An ImplicitParamDecl record.

@ DECL_FRIEND

A FriendDecl record.

@ DECL_CXX_METHOD

A CXXMethodDecl record.

@ DECL_EXPORT

An ExportDecl record.

@ DECL_BINDING

A BindingDecl record.

@ DECL_PRAGMA_COMMENT

A PragmaCommentDecl record.

@ DECL_ENUM

An EnumDecl record.

@ DECL_CONTEXT_MODULE_LOCAL_VISIBLE

A record containing the set of declarations that are only visible from DeclContext in the same module...

@ DECL_DECOMPOSITION

A DecompositionDecl record.

@ DECL_OMP_DECLARE_REDUCTION

An OMPDeclareReductionDecl record.

@ DECL_OMP_THREADPRIVATE

An OMPThreadPrivateDecl record.

@ DECL_OBJC_METHOD

A ObjCMethodDecl record.

@ DECL_CXX_DESTRUCTOR

A CXXDestructorDecl record.

@ DECL_OMP_CAPTUREDEXPR

An OMPCapturedExprDecl record.

@ DECL_CLASS_TEMPLATE

A ClassTemplateDecl record.

@ DECL_USING_SHADOW

A UsingShadowDecl record.

@ DECL_CONCEPT

A ConceptDecl record.

@ DECL_CXX_DEDUCTION_GUIDE

A CXXDeductionGuideDecl record.

@ DECL_OMP_REQUIRES

An OMPRequiresDecl record.

@ DECL_OBJC_IVAR

A ObjCIvarDecl record.

@ DECL_OBJC_PROPERTY

A ObjCPropertyDecl record.

@ DECL_TEMPLATE_PARAM_OBJECT

A TemplateParamObjectDecl record.

@ DECL_OBJC_INTERFACE

A ObjCInterfaceDecl record.

@ DECL_VAR_TEMPLATE

A VarTemplateDecl record.

@ DECL_LIFETIME_EXTENDED_TEMPORARY

An LifetimeExtendedTemporaryDecl record.

@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION

A ClassTemplatePartialSpecializationDecl record.

@ DECL_IMPLICIT_CONCEPT_SPECIALIZATION

An ImplicitConceptSpecializationDecl record.

@ DECL_CONTEXT_VISIBLE

A record that stores the set of declarations that are visible from a given DeclContext.

@ DECL_OBJC_PROPERTY_IMPL

A ObjCPropertyImplDecl record.

Defines the Linkage enumeration and various utility functions.

const internal::VariadicAllOfMatcher< Decl > decl

Matches declarations.

ComparisonCategoryResult Compare(const T &X, const T &Y)

Helper to compare two comparable types.

uint64_t TypeID

An ID number that refers to a type in an AST file.

uint32_t SubmoduleID

An ID number that refers to a submodule in a module file.

bool needsAnonymousDeclarationNumber(const NamedDecl *D)

Determine whether the given declaration needs an anonymous declaration number.

void numberAnonymousDeclsWithin(const DeclContext *DC, Fn Visit)

Visit each declaration within DC that needs an anonymous declaration number and call Visit with the d...

bool isPartOfPerModuleInitializer(const Decl *D)

Determine whether the given declaration will be included in the per-module initializer if it needs to...

@ UPD_CXX_RESOLVED_DTOR_DELETE

@ UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER

@ UPD_CXX_DEDUCED_RETURN_TYPE

@ UPD_CXX_ADDED_IMPLICIT_MEMBER

@ UPD_DECL_MARKED_OPENMP_DECLARETARGET

@ UPD_CXX_POINT_OF_INSTANTIATION

@ UPD_CXX_RESOLVED_EXCEPTION_SPEC

@ UPD_CXX_ADDED_FUNCTION_DEFINITION

@ UPD_DECL_MARKED_OPENMP_THREADPRIVATE

@ UPD_STATIC_LOCAL_NUMBER

@ UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT

@ UPD_ADDED_ATTR_TO_RECORD

@ UPD_DECL_MARKED_OPENMP_ALLOCATE

@ UPD_CXX_ADDED_ANONYMOUS_NAMESPACE

@ UPD_CXX_INSTANTIATED_CLASS_DEFINITION

@ UPD_CXX_ADDED_VAR_DEFINITION

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

SelectorLocationsKind

Whether all locations of the selector identifiers are in a "standard" position.

bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)

ConstexprSpecKind

Define the kind of constexpr specifier.

LinkageSpecLanguageIDs

Represents the language in a linkage specification.

LazyOffsetPtr< Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt > LazyDeclStmtPtr

A lazy pointer to a statement.

LambdaCaptureKind

The different capture forms in a lambda introducer.

@ LCK_ByCopy

Capturing by copy (a.k.a., by value)

@ LCK_ByRef

Capturing by reference.

@ LCK_VLAType

Capturing variable-length array type.

@ LCK_StarThis

Capturing the *this object by copy.

@ LCK_This

Capturing the *this object by reference.

OMPDeclareReductionInitKind

StorageClass

Storage classes.

Linkage

Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.

@ None

No linkage, which means that the entity is unique and can only be referred to from within its scope.

@ Result

The result type of a method or function.

TagTypeKind

The kind of a tag type.

ObjCImplementationControl

RecordArgPassingKind

Enum that represents the different ways arguments are passed to and returned from function calls.

static bool isUndeducedReturnType(QualType T)

bool operator!=(CanQual< T > x, CanQual< U > y)

for(const auto &A :T->param_types())

const FunctionProtoType * T

DeductionCandidate

Only used by CXXDeductionGuideDecl.

bool shouldSkipCheckingODR(const Decl *D)

bool declaresSameEntity(const Decl *D1, const Decl *D2)

Determine whether two declarations declare the same entity.

TemplateSpecializationKind

Describes the kind of template specialization that a particular template specialization declaration r...

@ Interface

The "__interface" keyword introduces the elaborated-type-specifier.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

@ Other

Other implicit parameter.

AccessSpecifier

A C++ access specifier (public, private, protected), plus the special value "none" which means differ...

Structure used to store a statement, the constant value to which it was evaluated (if any),...

bool HasConstantDestruction

Whether this variable is known to have constant destruction.

bool WasEvaluated

Whether this statement was already evaluated.

bool HasConstantInitialization

Whether this variable is known to have constant initialization.

Provides information about an explicit instantiation of a variable or class template.

SourceLocation ExternKeywordLoc

The location of the extern keyword.

Data that is common to all of the declarations of a given function template.

llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations

The function template specializations for this function template, including explicit specializations ...

A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...

Helper class that saves the current stream position and then restores it when destroyed.

llvm::DenseSet< std::tuple< Decl *, Decl *, int > > NonEquivalentDeclSet

Store declaration pairs already found to be non-equivalent.

Describes the categories of an Objective-C class.