clang 20.0.0git
ASTReaderDecl.cpp
Go to the documentation of this file.
1//===- ASTReaderDecl.cpp - Decl Deserialization ---------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the ASTReader::readDeclRecord method, which is the
10// entrypoint for loading a decl.
11//
12//===----------------------------------------------------------------------===//
13
14#include "ASTCommon.h"
15#include "ASTReaderInternals.h"
19#include "clang/AST/Attr.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclBase.h"
23#include "clang/AST/DeclCXX.h"
25#include "clang/AST/DeclObjC.h"
30#include "clang/AST/Expr.h"
36#include "clang/AST/Stmt.h"
38#include "clang/AST/Type.h"
44#include "clang/Basic/LLVM.h"
45#include "clang/Basic/Lambda.h"
47#include "clang/Basic/Linkage.h"
48#include "clang/Basic/Module.h"
52#include "clang/Basic/Stack.h"
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 <algorithm>
69#include <cassert>
70#include <cstdint>
71#include <cstring>
72#include <string>
73#include <utility>
74
75using namespace clang;
76using namespace serialization;
77
78//===----------------------------------------------------------------------===//
79// Declaration Merging
80//===----------------------------------------------------------------------===//
81
82namespace {
83/// Results from loading a RedeclarableDecl.
84class RedeclarableResult {
85 Decl *MergeWith;
86 GlobalDeclID FirstID;
87 bool IsKeyDecl;
88
89public:
90 RedeclarableResult(Decl *MergeWith, GlobalDeclID FirstID, bool IsKeyDecl)
91 : MergeWith(MergeWith), FirstID(FirstID), IsKeyDecl(IsKeyDecl) {}
92
93 /// Retrieve the first ID.
94 GlobalDeclID getFirstID() const { return FirstID; }
95
96 /// Is this declaration a key declaration?
97 bool isKeyDecl() const { return IsKeyDecl; }
98
99 /// Get a known declaration that this should be merged with, if
100 /// any.
101 Decl *getKnownMergeTarget() const { return MergeWith; }
102};
103} // namespace
104
105namespace clang {
107 ASTReader &Reader;
108
109public:
110 ASTDeclMerger(ASTReader &Reader) : Reader(Reader) {}
111
112 void mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl, Decl &Context,
113 unsigned Number);
114
115 /// \param KeyDeclID the decl ID of the key declaration \param D.
116 /// GlobalDeclID() if \param is not a key declaration.
117 /// See the comments of ASTReader::KeyDecls for the explanation
118 /// of key declaration.
119 template <typename T>
120 void mergeRedeclarableImpl(Redeclarable<T> *D, T *Existing,
121 GlobalDeclID KeyDeclID);
122
123 template <typename T>
125 RedeclarableResult &Redecl) {
127 D, Existing, Redecl.isKeyDecl() ? Redecl.getFirstID() : GlobalDeclID());
128 }
129
131 RedeclarableTemplateDecl *Existing, bool IsKeyDecl);
132
134 struct CXXRecordDecl::DefinitionData &&NewDD);
136 struct ObjCInterfaceDecl::DefinitionData &&NewDD);
138 struct ObjCProtocolDecl::DefinitionData &&NewDD);
139};
140} // namespace clang
141
142//===----------------------------------------------------------------------===//
143// Declaration deserialization
144//===----------------------------------------------------------------------===//
145
146namespace clang {
147class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
148 ASTReader &Reader;
149 ASTDeclMerger MergeImpl;
151 ASTReader::RecordLocation Loc;
152 const GlobalDeclID ThisDeclID;
153 const SourceLocation ThisDeclLoc;
154
156
157 TypeID DeferredTypeID = 0;
158 unsigned AnonymousDeclNumber = 0;
159 GlobalDeclID NamedDeclForTagDecl = GlobalDeclID();
160 IdentifierInfo *TypedefNameForLinkage = nullptr;
161
162 /// A flag to carry the information for a decl from the entity is
163 /// used. We use it to delay the marking of the canonical decl as used until
164 /// the entire declaration is deserialized and merged.
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
180 SourceLocation readSourceLocation() { return Record.readSourceLocation(); }
181
182 SourceRange readSourceRange() { return Record.readSourceRange(); }
183
184 TypeSourceInfo *readTypeSourceInfo() { return Record.readTypeSourceInfo(); }
185
186 GlobalDeclID readDeclID() { return Record.readDeclID(); }
187
188 std::string readString() { return Record.readString(); }
189
190 Decl *readDecl() { return Record.readDecl(); }
191
192 template <typename T> T *readDeclAs() { return Record.readDeclAs<T>(); }
193
194 serialization::SubmoduleID readSubmoduleID() {
195 if (Record.getIdx() == Record.size())
196 return 0;
197
198 return Record.getGlobalSubmoduleID(Record.readInt());
199 }
200
201 Module *readModule() { return Record.getSubmodule(readSubmoduleID()); }
202
203 void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
204 Decl *LambdaContext = nullptr,
205 unsigned IndexInLambdaContext = 0);
206 void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
207 const CXXRecordDecl *D, Decl *LambdaContext,
208 unsigned IndexInLambdaContext);
209 void ReadObjCDefinitionData(struct ObjCInterfaceDecl::DefinitionData &Data);
210 void ReadObjCDefinitionData(struct ObjCProtocolDecl::DefinitionData &Data);
211
212 static DeclContext *getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC);
213
214 static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
215 DeclContext *DC, unsigned Index);
216 static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
217 unsigned Index, NamedDecl *D);
218
219 /// Commit to a primary definition of the class RD, which is known to be
220 /// a definition of the class. We might not have read the definition data
221 /// for it yet. If we haven't then allocate placeholder definition data
222 /// now too.
223 static CXXRecordDecl *getOrFakePrimaryClassDefinition(ASTReader &Reader,
224 CXXRecordDecl *RD);
225
226 /// Class used to capture the result of searching for an existing
227 /// declaration of a specific kind and name, along with the ability
228 /// to update the place where this result was found (the declaration
229 /// chain hanging off an identifier or the DeclContext we searched in)
230 /// if requested.
231 class FindExistingResult {
232 ASTReader &Reader;
233 NamedDecl *New = nullptr;
234 NamedDecl *Existing = nullptr;
235 bool AddResult = false;
236 unsigned AnonymousDeclNumber = 0;
237 IdentifierInfo *TypedefNameForLinkage = nullptr;
238
239 public:
240 FindExistingResult(ASTReader &Reader) : Reader(Reader) {}
241
242 FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
243 unsigned AnonymousDeclNumber,
244 IdentifierInfo *TypedefNameForLinkage)
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 /// Suppress the addition of this result into the known set of
261 /// names.
262 void suppress() { AddResult = false; }
263
264 operator NamedDecl *() const { return Existing; }
265
266 template <typename T> operator T *() const {
267 return dyn_cast_or_null<T>(Existing);
268 }
269 };
270
271 static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
272 DeclContext *DC);
273 FindExistingResult findExisting(NamedDecl *D);
274
275public:
277 ASTReader::RecordLocation Loc, GlobalDeclID thisDeclID,
278 SourceLocation ThisDeclLoc)
279 : Reader(Reader), MergeImpl(Reader), Record(Record), Loc(Loc),
280 ThisDeclID(thisDeclID), ThisDeclLoc(ThisDeclLoc) {}
281
282 template <typename DeclT>
284 static Decl *getMostRecentDeclImpl(...);
285 static Decl *getMostRecentDecl(Decl *D);
286
287 template <typename DeclT>
289 Decl *Previous, Decl *Canon);
290 static void attachPreviousDeclImpl(ASTReader &Reader, ...);
291 static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
292 Decl *Canon);
293
295 Decl *Previous);
296
297 template <typename DeclT>
298 static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
299 static void attachLatestDeclImpl(...);
300 static void attachLatestDecl(Decl *D, Decl *latest);
301
302 template <typename DeclT>
304 static void markIncompleteDeclChainImpl(...);
305
307 llvm::BitstreamCursor &DeclsCursor, bool IsPartial);
308
310 void Visit(Decl *D);
311
312 void UpdateDecl(Decl *D);
313
315 ObjCCategoryDecl *Next) {
316 Cat->NextClassCategory = Next;
317 }
318
319 void VisitDecl(Decl *D);
323 void VisitNamedDecl(NamedDecl *ND);
324 void VisitLabelDecl(LabelDecl *LD);
329 void VisitTypeDecl(TypeDecl *TD);
330 RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
335 RedeclarableResult VisitTagDecl(TagDecl *TD);
336 void VisitEnumDecl(EnumDecl *ED);
337 RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
338 void VisitRecordDecl(RecordDecl *RD);
339 RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
341 RedeclarableResult
343
344 void
347 }
348
351 RedeclarableResult
353
356 }
357
361 void VisitValueDecl(ValueDecl *VD);
371 void VisitFieldDecl(FieldDecl *FD);
377 RedeclarableResult VisitVarDeclImpl(VarDecl *D);
378 void ReadVarDeclInit(VarDecl *VD);
387 void
411 void VisitBlockDecl(BlockDecl *BD);
416
417 void VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
418 uint64_t &VisibleOffset, uint64_t &ModuleLocalOffset,
419 uint64_t &TULocalOffset);
420
421 template <typename T>
422 RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
423
424 template <typename T>
425 void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
426
428 RedeclarableResult &Redecl);
429
430 template <typename T> void mergeMergeable(Mergeable<T> *D);
431
433
435
436 // FIXME: Reorder according to DeclNodes.td?
457};
458} // namespace clang
459
460namespace {
461
462/// Iterator over the redeclarations of a declaration that have already
463/// been merged into the same redeclaration chain.
464template <typename DeclT> 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 // If we started in the merged portion, we'll reach our start position
483 // eventually. Otherwise, we'll never reach it, but the second declaration
484 // we reached was the canonical declaration, so stop when we see that one
485 // again.
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} // namespace
498
499template <typename DeclT>
500static llvm::iterator_range<MergedRedeclIterator<DeclT>>
502 return llvm::make_range(MergedRedeclIterator<DeclT>(D),
503 MergedRedeclIterator<DeclT>());
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 ||
514 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
515 }
516 if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
517 CD->setNumCtorInitializers(Record.readInt());
518 if (CD->getNumCtorInitializers())
519 CD->CtorInitializers = ReadGlobalOffset();
520 }
521 // Store the offset of the body so we can lazily load it later.
522 Reader.PendingBodies[FD] = GetCurrentCursorOffset();
523}
524
527
528 // At this point we have deserialized and merged the decl and it is safe to
529 // update its canonical decl to signal that the entire entity is used.
530 D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;
531 IsDeclMarkedUsed = false;
532
533 if (auto *DD = dyn_cast<DeclaratorDecl>(D)) {
534 if (auto *TInfo = DD->getTypeSourceInfo())
535 Record.readTypeLoc(TInfo->getTypeLoc());
536 }
537
538 if (auto *TD = dyn_cast<TypeDecl>(D)) {
539 // We have a fully initialized TypeDecl. Read its type now.
540 TD->setTypeForDecl(Reader.GetType(DeferredTypeID).getTypePtrOrNull());
541
542 // If this is a tag declaration with a typedef name for linkage, it's safe
543 // to load that typedef now.
544 if (NamedDeclForTagDecl.isValid())
545 cast<TagDecl>(D)->TypedefNameDeclOrQualifier =
546 cast<TypedefNameDecl>(Reader.GetDecl(NamedDeclForTagDecl));
547 } else if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
548 // if we have a fully initialized TypeDecl, we can safely read its type now.
549 ID->TypeForDecl = Reader.GetType(DeferredTypeID).getTypePtrOrNull();
550 } else if (auto *FD = dyn_cast<FunctionDecl>(D)) {
551 // FunctionDecl's body was written last after all other Stmts/Exprs.
552 if (Record.readInt())
554 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
555 ReadVarDeclInit(VD);
556 } else if (auto *FD = dyn_cast<FieldDecl>(D)) {
557 if (FD->hasInClassInitializer() && Record.readInt()) {
558 FD->setLazyInClassInitializer(LazyDeclStmtPtr(GetCurrentCursorOffset()));
559 }
560 }
561}
562
564 BitsUnpacker DeclBits(Record.readInt());
565 auto ModuleOwnership =
566 (Decl::ModuleOwnershipKind)DeclBits.getNextBits(/*Width=*/3);
567 D->setReferenced(DeclBits.getNextBit());
568 D->Used = DeclBits.getNextBit();
569 IsDeclMarkedUsed |= D->Used;
570 D->setAccess((AccessSpecifier)DeclBits.getNextBits(/*Width=*/2));
571 D->setImplicit(DeclBits.getNextBit());
572 bool HasStandaloneLexicalDC = DeclBits.getNextBit();
573 bool HasAttrs = DeclBits.getNextBit();
575 D->InvalidDecl = DeclBits.getNextBit();
576 D->FromASTFile = true;
577
579 isa<ParmVarDecl, ObjCTypeParamDecl>(D)) {
580 // We don't want to deserialize the DeclContext of a template
581 // parameter or of a parameter of a function template immediately. These
582 // entities might be used in the formulation of its DeclContext (for
583 // example, a function parameter can be used in decltype() in trailing
584 // return type of the function). Use the translation unit DeclContext as a
585 // placeholder.
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<DeclContext>();
597 auto *LexicalDC =
598 HasStandaloneLexicalDC ? readDeclAs<DeclContext>() : nullptr;
599 if (!LexicalDC)
600 LexicalDC = SemaDC;
601 // If the context is a class, we might not have actually merged it yet, in
602 // the case where the definition comes from an update record.
603 DeclContext *MergedSemaDC;
604 if (auto *RD = dyn_cast<CXXRecordDecl>(SemaDC))
605 MergedSemaDC = getOrFakePrimaryClassDefinition(Reader, RD);
606 else
607 MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
608 // Avoid calling setLexicalDeclContext() directly because it uses
609 // Decl::getASTContext() internally which is unsafe during derialization.
610 D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
611 Reader.getContext());
612 }
613 D->setLocation(ThisDeclLoc);
614
615 if (HasAttrs) {
616 AttrVec Attrs;
617 Record.readAttributes(Attrs);
618 // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
619 // internally which is unsafe during derialization.
620 D->setAttrsImpl(Attrs, Reader.getContext());
621 }
622
623 // Determine whether this declaration is part of a (sub)module. If so, it
624 // may not yet be visible.
625 bool ModulePrivate =
626 (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate);
627 if (unsigned SubmoduleID = readSubmoduleID()) {
628 switch (ModuleOwnership) {
631 break;
636 break;
637 }
638
639 D->setModuleOwnershipKind(ModuleOwnership);
640 // Store the owning submodule ID in the declaration.
642
643 if (ModulePrivate) {
644 // Module-private declarations are never visible, so there is no work to
645 // do.
646 } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
647 // If local visibility is being tracked, this declaration will become
648 // hidden and visible as the owning module does.
649 } else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
650 // Mark the declaration as visible when its owning module becomes visible.
651 if (Owner->NameVisibility == Module::AllVisible)
653 else
654 Reader.HiddenNamesMap[Owner].push_back(D);
655 }
656 } else if (ModulePrivate) {
658 }
659}
660
662 VisitDecl(D);
663 D->setLocation(readSourceLocation());
664 D->CommentKind = (PragmaMSCommentKind)Record.readInt();
665 std::string Arg = readString();
666 memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
667 D->getTrailingObjects<char>()[Arg.size()] = '\0';
668}
669
671 VisitDecl(D);
672 D->setLocation(readSourceLocation());
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(),
680 Value.size());
681 D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
682}
683
685 llvm_unreachable("Translation units are not serialized");
686}
687
689 VisitDecl(ND);
690 ND->setDeclName(Record.readDeclarationName());
691 AnonymousDeclNumber = Record.readInt();
692}
693
695 VisitNamedDecl(TD);
696 TD->setLocStart(readSourceLocation());
697 // Delay type reading until after we have fully initialized the decl.
698 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
699}
700
702 RedeclarableResult Redecl = VisitRedeclarable(TD);
703 VisitTypeDecl(TD);
704 TypeSourceInfo *TInfo = readTypeSourceInfo();
705 if (Record.readInt()) { // isModed
706 QualType modedT = Record.readType();
707 TD->setModedTypeSourceInfo(TInfo, modedT);
708 } else
709 TD->setTypeSourceInfo(TInfo);
710 // Read and discard the declaration for which this is a typedef name for
711 // linkage, if it exists. We cannot rely on our type to pull in this decl,
712 // because it might have been merged with a type from another module and
713 // thus might not refer to our version of the declaration.
714 readDecl();
715 return Redecl;
716}
717
719 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
720 mergeRedeclarable(TD, Redecl);
721}
722
724 RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
725 if (auto *Template = readDeclAs<TypeAliasTemplateDecl>())
726 // Merged when we merge the template.
727 TD->setDescribedAliasTemplate(Template);
728 else
729 mergeRedeclarable(TD, Redecl);
730}
731
732RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
733 RedeclarableResult Redecl = VisitRedeclarable(TD);
734 VisitTypeDecl(TD);
735
736 TD->IdentifierNamespace = Record.readInt();
737
738 BitsUnpacker TagDeclBits(Record.readInt());
739 TD->setTagKind(
740 static_cast<TagTypeKind>(TagDeclBits.getNextBits(/*Width=*/3)));
741 TD->setCompleteDefinition(TagDeclBits.getNextBit());
742 TD->setEmbeddedInDeclarator(TagDeclBits.getNextBit());
743 TD->setFreeStanding(TagDeclBits.getNextBit());
744 TD->setCompleteDefinitionRequired(TagDeclBits.getNextBit());
745 TD->setBraceRange(readSourceRange());
746
747 switch (TagDeclBits.getNextBits(/*Width=*/2)) {
748 case 0:
749 break;
750 case 1: { // ExtInfo
751 auto *Info = new (Reader.getContext()) TagDecl::ExtInfo();
752 Record.readQualifierInfo(*Info);
753 TD->TypedefNameDeclOrQualifier = Info;
754 break;
755 }
756 case 2: // TypedefNameForAnonDecl
757 NamedDeclForTagDecl = readDeclID();
758 TypedefNameForLinkage = Record.readIdentifier();
759 break;
760 default:
761 llvm_unreachable("unexpected tag info kind");
762 }
763
764 if (!isa<CXXRecordDecl>(TD))
765 mergeRedeclarable(TD, Redecl);
766 return Redecl;
767}
768
770 VisitTagDecl(ED);
771 if (TypeSourceInfo *TI = readTypeSourceInfo())
773 else
774 ED->setIntegerType(Record.readType());
775 ED->setPromotionType(Record.readType());
776
777 BitsUnpacker EnumDeclBits(Record.readInt());
778 ED->setNumPositiveBits(EnumDeclBits.getNextBits(/*Width=*/8));
779 ED->setNumNegativeBits(EnumDeclBits.getNextBits(/*Width=*/8));
780 ED->setScoped(EnumDeclBits.getNextBit());
781 ED->setScopedUsingClassTag(EnumDeclBits.getNextBit());
782 ED->setFixed(EnumDeclBits.getNextBit());
783
784 ED->setHasODRHash(true);
785 ED->ODRHash = Record.readInt();
786
787 // If this is a definition subject to the ODR, and we already have a
788 // definition, merge this one into it.
789 if (ED->isCompleteDefinition() && Reader.getContext().getLangOpts().Modules) {
790 EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
791 if (!OldDef) {
792 // This is the first time we've seen an imported definition. Look for a
793 // local definition before deciding that we are the first definition.
794 for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
795 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
796 OldDef = D;
797 break;
798 }
799 }
800 }
801 if (OldDef) {
802 Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
804 Reader.mergeDefinitionVisibility(OldDef, ED);
805 // We don't want to check the ODR hash value for declarations from global
806 // module fragment.
807 if (!shouldSkipCheckingODR(ED) && !shouldSkipCheckingODR(OldDef) &&
808 OldDef->getODRHash() != ED->getODRHash())
809 Reader.PendingEnumOdrMergeFailures[OldDef].push_back(ED);
810 } else {
811 OldDef = ED;
812 }
813 }
814
815 if (auto *InstED = readDeclAs<EnumDecl>()) {
816 auto TSK = (TemplateSpecializationKind)Record.readInt();
817 SourceLocation POI = readSourceLocation();
818 ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
820 }
821}
822
824 RedeclarableResult Redecl = VisitTagDecl(RD);
825
826 BitsUnpacker RecordDeclBits(Record.readInt());
827 RD->setHasFlexibleArrayMember(RecordDeclBits.getNextBit());
828 RD->setAnonymousStructOrUnion(RecordDeclBits.getNextBit());
829 RD->setHasObjectMember(RecordDeclBits.getNextBit());
830 RD->setHasVolatileMember(RecordDeclBits.getNextBit());
832 RD->setNonTrivialToPrimitiveCopy(RecordDeclBits.getNextBit());
833 RD->setNonTrivialToPrimitiveDestroy(RecordDeclBits.getNextBit());
835 RecordDeclBits.getNextBit());
839 RD->setParamDestroyedInCallee(RecordDeclBits.getNextBit());
841 (RecordArgPassingKind)RecordDeclBits.getNextBits(/*Width=*/2));
842 return Redecl;
843}
844
847 RD->setODRHash(Record.readInt());
848
849 // Maintain the invariant of a redeclaration chain containing only
850 // a single definition.
851 if (RD->isCompleteDefinition()) {
852 RecordDecl *Canon = static_cast<RecordDecl *>(RD->getCanonicalDecl());
853 RecordDecl *&OldDef = Reader.RecordDefinitions[Canon];
854 if (!OldDef) {
855 // This is the first time we've seen an imported definition. Look for a
856 // local definition before deciding that we are the first definition.
857 for (auto *D : merged_redecls(Canon)) {
858 if (!D->isFromASTFile() && D->isCompleteDefinition()) {
859 OldDef = D;
860 break;
861 }
862 }
863 }
864 if (OldDef) {
865 Reader.MergedDeclContexts.insert(std::make_pair(RD, OldDef));
867 Reader.mergeDefinitionVisibility(OldDef, RD);
868 if (OldDef->getODRHash() != RD->getODRHash())
869 Reader.PendingRecordOdrMergeFailures[OldDef].push_back(RD);
870 } else {
871 OldDef = RD;
872 }
873 }
874}
875
877 VisitNamedDecl(VD);
878 // For function or variable declarations, defer reading the type in case the
879 // declaration has a deduced type that references an entity declared within
880 // the function definition or variable initializer.
881 if (isa<FunctionDecl, VarDecl>(VD))
882 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
883 else
884 VD->setType(Record.readType());
885}
886
888 VisitValueDecl(ECD);
889 if (Record.readInt())
890 ECD->setInitExpr(Record.readExpr());
891 ECD->setInitVal(Reader.getContext(), Record.readAPSInt());
892 mergeMergeable(ECD);
893}
894
896 VisitValueDecl(DD);
897 DD->setInnerLocStart(readSourceLocation());
898 if (Record.readInt()) { // hasExtInfo
899 auto *Info = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
900 Record.readQualifierInfo(*Info);
901 Info->TrailingRequiresClause = Record.readExpr();
902 DD->DeclInfo = Info;
903 }
904 QualType TSIType = Record.readType();
906 TSIType.isNull() ? nullptr
907 : Reader.getContext().CreateTypeSourceInfo(TSIType));
908}
909
911 RedeclarableResult Redecl = VisitRedeclarable(FD);
912
913 FunctionDecl *Existing = nullptr;
914
915 switch ((FunctionDecl::TemplatedKind)Record.readInt()) {
917 break;
919 FD->setInstantiatedFromDecl(readDeclAs<FunctionDecl>());
920 break;
922 auto *Template = readDeclAs<FunctionTemplateDecl>();
923 Template->init(FD);
924 FD->setDescribedFunctionTemplate(Template);
925 break;
926 }
928 auto *InstFD = readDeclAs<FunctionDecl>();
929 auto TSK = (TemplateSpecializationKind)Record.readInt();
930 SourceLocation POI = readSourceLocation();
931 FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
933 break;
934 }
936 auto *Template = readDeclAs<FunctionTemplateDecl>();
937 auto TSK = (TemplateSpecializationKind)Record.readInt();
938
939 // Template arguments.
941 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
942
943 // Template args as written.
944 TemplateArgumentListInfo TemplArgsWritten;
945 bool HasTemplateArgumentsAsWritten = Record.readBool();
946 if (HasTemplateArgumentsAsWritten)
947 Record.readTemplateArgumentListInfo(TemplArgsWritten);
948
949 SourceLocation POI = readSourceLocation();
950
951 ASTContext &C = Reader.getContext();
952 TemplateArgumentList *TemplArgList =
954
955 MemberSpecializationInfo *MSInfo = nullptr;
956 if (Record.readInt()) {
957 auto *FD = readDeclAs<FunctionDecl>();
958 auto TSK = (TemplateSpecializationKind)Record.readInt();
959 SourceLocation POI = readSourceLocation();
960
961 MSInfo = new (C) MemberSpecializationInfo(FD, TSK);
962 MSInfo->setPointOfInstantiation(POI);
963 }
964
967 C, FD, Template, TSK, TemplArgList,
968 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr, POI,
969 MSInfo);
970 FD->TemplateOrSpecialization = FTInfo;
971
972 if (FD->isCanonicalDecl()) { // if canonical add to template's set.
973 // The template that contains the specializations set. It's not safe to
974 // use getCanonicalDecl on Template since it may still be initializing.
975 auto *CanonTemplate = readDeclAs<FunctionTemplateDecl>();
976 // Get the InsertPos by FindNodeOrInsertPos() instead of calling
977 // InsertNode(FTInfo) directly to avoid the getASTContext() call in
978 // FunctionTemplateSpecializationInfo's Profile().
979 // We avoid getASTContext because a decl in the parent hierarchy may
980 // be initializing.
981 llvm::FoldingSetNodeID ID;
983 void *InsertPos = nullptr;
984 FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
986 CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
987 if (InsertPos)
988 CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
989 else {
990 assert(Reader.getContext().getLangOpts().Modules &&
991 "already deserialized this template specialization");
992 Existing = ExistingInfo->getFunction();
993 }
994 }
995 break;
996 }
998 // Templates.
999 UnresolvedSet<8> Candidates;
1000 unsigned NumCandidates = Record.readInt();
1001 while (NumCandidates--)
1002 Candidates.addDecl(readDeclAs<NamedDecl>());
1003
1004 // Templates args.
1005 TemplateArgumentListInfo TemplArgsWritten;
1006 bool HasTemplateArgumentsAsWritten = Record.readBool();
1007 if (HasTemplateArgumentsAsWritten)
1008 Record.readTemplateArgumentListInfo(TemplArgsWritten);
1009
1011 Reader.getContext(), Candidates,
1012 HasTemplateArgumentsAsWritten ? &TemplArgsWritten : nullptr);
1013 // These are not merged; we don't need to merge redeclarations of dependent
1014 // template friends.
1015 break;
1016 }
1017 }
1018
1020
1021 // Attach a type to this function. Use the real type if possible, but fall
1022 // back to the type as written if it involves a deduced return type.
1023 if (FD->getTypeSourceInfo() && FD->getTypeSourceInfo()
1024 ->getType()
1025 ->castAs<FunctionType>()
1026 ->getReturnType()
1028 // We'll set up the real type in Visit, once we've finished loading the
1029 // function.
1030 FD->setType(FD->getTypeSourceInfo()->getType());
1031 Reader.PendingDeducedFunctionTypes.push_back({FD, DeferredTypeID});
1032 } else {
1033 FD->setType(Reader.GetType(DeferredTypeID));
1034 }
1035 DeferredTypeID = 0;
1036
1037 FD->DNLoc = Record.readDeclarationNameLoc(FD->getDeclName());
1038 FD->IdentifierNamespace = Record.readInt();
1039
1040 // FunctionDecl's body is handled last at ASTDeclReader::Visit,
1041 // after everything else is read.
1042 BitsUnpacker FunctionDeclBits(Record.readInt());
1043
1044 FD->setCachedLinkage((Linkage)FunctionDeclBits.getNextBits(/*Width=*/3));
1045 FD->setStorageClass((StorageClass)FunctionDeclBits.getNextBits(/*Width=*/3));
1046 FD->setInlineSpecified(FunctionDeclBits.getNextBit());
1047 FD->setImplicitlyInline(FunctionDeclBits.getNextBit());
1048 FD->setHasSkippedBody(FunctionDeclBits.getNextBit());
1049 FD->setVirtualAsWritten(FunctionDeclBits.getNextBit());
1050 // We defer calling `FunctionDecl::setPure()` here as for methods of
1051 // `CXXTemplateSpecializationDecl`s, we may not have connected up the
1052 // definition (which is required for `setPure`).
1053 const bool Pure = FunctionDeclBits.getNextBit();
1054 FD->setHasInheritedPrototype(FunctionDeclBits.getNextBit());
1055 FD->setHasWrittenPrototype(FunctionDeclBits.getNextBit());
1056 FD->setDeletedAsWritten(FunctionDeclBits.getNextBit());
1057 FD->setTrivial(FunctionDeclBits.getNextBit());
1058 FD->setTrivialForCall(FunctionDeclBits.getNextBit());
1059 FD->setDefaulted(FunctionDeclBits.getNextBit());
1060 FD->setExplicitlyDefaulted(FunctionDeclBits.getNextBit());
1061 FD->setIneligibleOrNotSelected(FunctionDeclBits.getNextBit());
1062 FD->setConstexprKind(
1063 (ConstexprSpecKind)FunctionDeclBits.getNextBits(/*Width=*/2));
1064 FD->setHasImplicitReturnZero(FunctionDeclBits.getNextBit());
1065 FD->setIsMultiVersion(FunctionDeclBits.getNextBit());
1066 FD->setLateTemplateParsed(FunctionDeclBits.getNextBit());
1068 FunctionDeclBits.getNextBit());
1069 FD->setUsesSEHTry(FunctionDeclBits.getNextBit());
1070
1071 FD->EndRangeLoc = readSourceLocation();
1072 if (FD->isExplicitlyDefaulted())
1073 FD->setDefaultLoc(readSourceLocation());
1074
1075 FD->ODRHash = Record.readInt();
1076 FD->setHasODRHash(true);
1077
1078 if (FD->isDefaulted() || FD->isDeletedAsWritten()) {
1079 // If 'Info' is nonzero, we need to read an DefaultedOrDeletedInfo; if,
1080 // additionally, the second bit is also set, we also need to read
1081 // a DeletedMessage for the DefaultedOrDeletedInfo.
1082 if (auto Info = Record.readInt()) {
1083 bool HasMessage = Info & 2;
1084 StringLiteral *DeletedMessage =
1085 HasMessage ? cast<StringLiteral>(Record.readExpr()) : nullptr;
1086
1087 unsigned NumLookups = Record.readInt();
1089 for (unsigned I = 0; I != NumLookups; ++I) {
1090 NamedDecl *ND = Record.readDeclAs<NamedDecl>();
1091 AccessSpecifier AS = (AccessSpecifier)Record.readInt();
1092 Lookups.push_back(DeclAccessPair::make(ND, AS));
1093 }
1094
1097 Reader.getContext(), Lookups, DeletedMessage));
1098 }
1099 }
1100
1101 if (Existing)
1102 MergeImpl.mergeRedeclarable(FD, Existing, Redecl);
1103 else if (auto Kind = FD->getTemplatedKind();
1106 // Function Templates have their FunctionTemplateDecls merged instead of
1107 // their FunctionDecls.
1108 auto merge = [this, &Redecl, FD](auto &&F) {
1109 auto *Existing = cast_or_null<FunctionDecl>(Redecl.getKnownMergeTarget());
1110 RedeclarableResult NewRedecl(Existing ? F(Existing) : nullptr,
1111 Redecl.getFirstID(), Redecl.isKeyDecl());
1112 mergeRedeclarableTemplate(F(FD), NewRedecl);
1113 };
1115 merge(
1116 [](FunctionDecl *FD) { return FD->getDescribedFunctionTemplate(); });
1117 else
1118 merge([](FunctionDecl *FD) {
1119 return FD->getTemplateSpecializationInfo()->getTemplate();
1120 });
1121 } else
1122 mergeRedeclarable(FD, Redecl);
1123
1124 // Defer calling `setPure` until merging above has guaranteed we've set
1125 // `DefinitionData` (as this will need to access it).
1126 FD->setIsPureVirtual(Pure);
1127
1128 // Read in the parameters.
1129 unsigned NumParams = Record.readInt();
1131 Params.reserve(NumParams);
1132 for (unsigned I = 0; I != NumParams; ++I)
1133 Params.push_back(readDeclAs<ParmVarDecl>());
1134 FD->setParams(Reader.getContext(), Params);
1135
1136 // If the declaration is a SYCL kernel entry point function as indicated by
1137 // the presence of a sycl_kernel_entry_point attribute, register it so that
1138 // associated metadata is recreated.
1139 if (FD->hasAttr<SYCLKernelEntryPointAttr>()) {
1140 auto *SKEPAttr = FD->getAttr<SYCLKernelEntryPointAttr>();
1141 ASTContext &C = Reader.getContext();
1142 const SYCLKernelInfo *SKI = C.findSYCLKernelInfo(SKEPAttr->getKernelName());
1143 if (SKI) {
1145 Reader.Diag(FD->getLocation(), diag::err_sycl_kernel_name_conflict);
1146 Reader.Diag(SKI->getKernelEntryPointDecl()->getLocation(),
1147 diag::note_previous_declaration);
1148 SKEPAttr->setInvalidAttr();
1149 }
1150 } else {
1151 C.registerSYCLEntryPointFunction(FD);
1152 }
1153 }
1154}
1155
1157 VisitNamedDecl(MD);
1158 if (Record.readInt()) {
1159 // Load the body on-demand. Most clients won't care, because method
1160 // definitions rarely show up in headers.
1161 Reader.PendingBodies[MD] = GetCurrentCursorOffset();
1162 }
1163 MD->setSelfDecl(readDeclAs<ImplicitParamDecl>());
1164 MD->setCmdDecl(readDeclAs<ImplicitParamDecl>());
1165 MD->setInstanceMethod(Record.readInt());
1166 MD->setVariadic(Record.readInt());
1167 MD->setPropertyAccessor(Record.readInt());
1168 MD->setSynthesizedAccessorStub(Record.readInt());
1169 MD->setDefined(Record.readInt());
1170 MD->setOverriding(Record.readInt());
1171 MD->setHasSkippedBody(Record.readInt());
1172
1173 MD->setIsRedeclaration(Record.readInt());
1174 MD->setHasRedeclaration(Record.readInt());
1175 if (MD->hasRedeclaration())
1177 readDeclAs<ObjCMethodDecl>());
1178
1180 static_cast<ObjCImplementationControl>(Record.readInt()));
1182 MD->setRelatedResultType(Record.readInt());
1183 MD->setReturnType(Record.readType());
1184 MD->setReturnTypeSourceInfo(readTypeSourceInfo());
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<ParmVarDecl>());
1191
1192 MD->setSelLocsKind((SelectorLocationsKind)Record.readInt());
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
1212 VisitNamedDecl(CD);
1213 CD->setAtStartLoc(readSourceLocation());
1214 CD->setAtEndRange(readSourceRange());
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<ObjCTypeParamDecl>();
1226 if (!typeParam)
1227 return nullptr;
1228
1229 typeParams.push_back(typeParam);
1230 }
1231
1232 SourceLocation lAngleLoc = readSourceLocation();
1233 SourceLocation rAngleLoc = readSourceLocation();
1234
1235 return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
1236 typeParams, rAngleLoc);
1237}
1238
1239void ASTDeclReader::ReadObjCDefinitionData(
1240 struct ObjCInterfaceDecl::DefinitionData &Data) {
1241 // Read the superclass.
1242 Data.SuperClassTInfo = readTypeSourceInfo();
1243
1244 Data.EndLoc = readSourceLocation();
1245 Data.HasDesignatedInitializers = Record.readInt();
1246 Data.ODRHash = Record.readInt();
1247 Data.HasODRHash = true;
1248
1249 // Read the directly referenced protocols and their SourceLocations.
1250 unsigned NumProtocols = Record.readInt();
1252 Protocols.reserve(NumProtocols);
1253 for (unsigned I = 0; I != NumProtocols; ++I)
1254 Protocols.push_back(readDeclAs<ObjCProtocolDecl>());
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(),
1260 Reader.getContext());
1261
1262 // Read the transitive closure of protocols referenced by this class.
1263 NumProtocols = Record.readInt();
1264 Protocols.clear();
1265 Protocols.reserve(NumProtocols);
1266 for (unsigned I = 0; I != NumProtocols; ++I)
1267 Protocols.push_back(readDeclAs<ObjCProtocolDecl>());
1268 Data.AllReferencedProtocols.set(Protocols.data(), NumProtocols,
1269 Reader.getContext());
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));
1280 Reader.mergeDefinitionVisibility(DD.Definition, NewDD.Definition);
1281
1282 if (D->getODRHash() != NewDD.ODRHash)
1283 Reader.PendingObjCInterfaceOdrMergeFailures[DD.Definition].push_back(
1284 {NewDD.Definition, &NewDD});
1285}
1286
1288 RedeclarableResult Redecl = VisitRedeclarable(ID);
1290 DeferredTypeID = Record.getGlobalTypeID(Record.readInt());
1291 mergeRedeclarable(ID, Redecl);
1292
1293 ID->TypeParamList = ReadObjCTypeParamList();
1294 if (Record.readInt()) {
1295 // Read the definition.
1296 ID->allocateDefinitionData();
1297
1298 ReadObjCDefinitionData(ID->data());
1299 ObjCInterfaceDecl *Canon = ID->getCanonicalDecl();
1300 if (Canon->Data.getPointer()) {
1301 // If we already have a definition, keep the definition invariant and
1302 // merge the data.
1303 MergeImpl.MergeDefinitionData(Canon, std::move(ID->data()));
1304 ID->Data = Canon->Data;
1305 } else {
1306 // Set the definition data of the canonical declaration, so other
1307 // redeclarations will see it.
1308 ID->getCanonicalDecl()->Data = ID->Data;
1309
1310 // We will rebuild this list lazily.
1311 ID->setIvarList(nullptr);
1312 }
1313
1314 // Note that we have deserialized a definition.
1315 Reader.PendingDefinitions.insert(ID);
1316
1317 // Note that we've loaded this Objective-C class.
1318 Reader.ObjCClassesLoaded.push_back(ID);
1319 } else {
1320 ID->Data = ID->getCanonicalDecl()->Data;
1321 }
1322}
1323
1325 VisitFieldDecl(IVD);
1327 // This field will be built lazily.
1328 IVD->setNextIvar(nullptr);
1329 bool synth = Record.readInt();
1330 IVD->setSynthesize(synth);
1331
1332 // Check ivar redeclaration.
1333 if (IVD->isInvalidDecl())
1334 return;
1335 // Don't check ObjCInterfaceDecl as interfaces are named and mismatches can be
1336 // detected in VisitObjCInterfaceDecl. Here we are looking for redeclarations
1337 // in extensions.
1338 if (isa<ObjCInterfaceDecl>(IVD->getDeclContext()))
1339 return;
1340 ObjCInterfaceDecl *CanonIntf =
1342 IdentifierInfo *II = IVD->getIdentifier();
1343 ObjCIvarDecl *PrevIvar = CanonIntf->lookupInstanceVariable(II);
1344 if (PrevIvar && PrevIvar != IVD) {
1345 auto *ParentExt = dyn_cast<ObjCCategoryDecl>(IVD->getDeclContext());
1346 auto *PrevParentExt =
1347 dyn_cast<ObjCCategoryDecl>(PrevIvar->getDeclContext());
1348 if (ParentExt && PrevParentExt) {
1349 // Postpone diagnostic as we should merge identical extensions from
1350 // different modules.
1351 Reader
1352 .PendingObjCExtensionIvarRedeclarations[std::make_pair(ParentExt,
1353 PrevParentExt)]
1354 .push_back(std::make_pair(IVD, PrevIvar));
1355 } else if (ParentExt || PrevParentExt) {
1356 // Duplicate ivars in extension + implementation are never compatible.
1357 // Compatibility of implementation + implementation should be handled in
1358 // VisitObjCImplementationDecl.
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<ObjCProtocolDecl>());
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());
1379 Data.ODRHash = Record.readInt();
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));
1391 Reader.mergeDefinitionVisibility(DD.Definition, NewDD.Definition);
1392
1393 if (D->getODRHash() != NewDD.ODRHash)
1394 Reader.PendingObjCProtocolOdrMergeFailures[DD.Definition].push_back(
1395 {NewDD.Definition, &NewDD});
1396}
1397
1399 RedeclarableResult Redecl = VisitRedeclarable(PD);
1401 mergeRedeclarable(PD, Redecl);
1402
1403 if (Record.readInt()) {
1404 // Read the definition.
1405 PD->allocateDefinitionData();
1406
1407 ReadObjCDefinitionData(PD->data());
1408
1409 ObjCProtocolDecl *Canon = PD->getCanonicalDecl();
1410 if (Canon->Data.getPointer()) {
1411 // If we already have a definition, keep the definition invariant and
1412 // merge the data.
1413 MergeImpl.MergeDefinitionData(Canon, std::move(PD->data()));
1414 PD->Data = Canon->Data;
1415 } else {
1416 // Set the definition data of the canonical declaration, so other
1417 // redeclarations will see it.
1418 PD->getCanonicalDecl()->Data = PD->Data;
1419 }
1420 // Note that we have deserialized a definition.
1421 Reader.PendingDefinitions.insert(PD);
1422 } else {
1423 PD->Data = PD->getCanonicalDecl()->Data;
1424 }
1425}
1426
1428 VisitFieldDecl(FD);
1429}
1430
1433 CD->setCategoryNameLoc(readSourceLocation());
1434 CD->setIvarLBraceLoc(readSourceLocation());
1435 CD->setIvarRBraceLoc(readSourceLocation());
1436
1437 // Note that this category has been deserialized. We do this before
1438 // deserializing the interface declaration, so that it will consider this
1439 /// category.
1440 Reader.CategoriesDeserialized.insert(CD);
1441
1442 CD->ClassInterface = readDeclAs<ObjCInterfaceDecl>();
1443 CD->TypeParamList = ReadObjCTypeParamList();
1444 unsigned NumProtoRefs = Record.readInt();
1446 ProtoRefs.reserve(NumProtoRefs);
1447 for (unsigned I = 0; I != NumProtoRefs; ++I)
1448 ProtoRefs.push_back(readDeclAs<ObjCProtocolDecl>());
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(),
1454 Reader.getContext());
1455
1456 // Protocols in the class extension belong to the class.
1457 if (NumProtoRefs > 0 && CD->ClassInterface && CD->IsClassExtension())
1458 CD->ClassInterface->mergeClassExtensionProtocolList(
1459 (ObjCProtocolDecl *const *)ProtoRefs.data(), NumProtoRefs,
1460 Reader.getContext());
1461}
1462
1464 VisitNamedDecl(CAD);
1465 CAD->setClassInterface(readDeclAs<ObjCInterfaceDecl>());
1466}
1467
1470 D->setAtLoc(readSourceLocation());
1471 D->setLParenLoc(readSourceLocation());
1472 QualType T = Record.readType();
1473 TypeSourceInfo *TSI = readTypeSourceInfo();
1474 D->setType(T, TSI);
1475 D->setPropertyAttributes((ObjCPropertyAttribute::Kind)Record.readInt());
1476 D->setPropertyAttributesAsWritten(
1478 D->setPropertyImplementation(
1480 DeclarationName GetterName = Record.readDeclarationName();
1481 SourceLocation GetterLoc = readSourceLocation();
1482 D->setGetterName(GetterName.getObjCSelector(), GetterLoc);
1483 DeclarationName SetterName = Record.readDeclarationName();
1484 SourceLocation SetterLoc = readSourceLocation();
1485 D->setSetterName(SetterName.getObjCSelector(), SetterLoc);
1486 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1487 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1488 D->setPropertyIvarDecl(readDeclAs<ObjCIvarDecl>());
1489}
1490
1493 D->setClassInterface(readDeclAs<ObjCInterfaceDecl>());
1494}
1495
1498 D->CategoryNameLoc = readSourceLocation();
1499}
1500
1503 D->setSuperClass(readDeclAs<ObjCInterfaceDecl>());
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
1515 VisitDecl(D);
1516 D->setAtLoc(readSourceLocation());
1517 D->setPropertyDecl(readDeclAs<ObjCPropertyDecl>());
1518 D->PropertyIvarDecl = readDeclAs<ObjCIvarDecl>();
1519 D->IvarLoc = readSourceLocation();
1520 D->setGetterMethodDecl(readDeclAs<ObjCMethodDecl>());
1521 D->setSetterMethodDecl(readDeclAs<ObjCMethodDecl>());
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)
1533 FD->CapturedVLAType =
1534 cast<VariableArrayType>(Record.readType().getTypePtr());
1535 else if (Bits & 1)
1536 FD->setBitWidth(Record.readExpr());
1537
1538 if (!FD->getDeclName() ||
1539 FD->isPlaceholderVar(Reader.getContext().getLangOpts())) {
1540 if (auto *Tmpl = readDeclAs<FieldDecl>())
1542 }
1543 mergeMergeable(FD);
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)
1558 C = Record.readInt();
1559
1560 // Add this GUID to the AST context's lookup structure, and merge if needed.
1561 if (MSGuidDecl *Existing = Reader.getContext().MSGuidDecls.GetOrInsertNode(D))
1562 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1563}
1564
1568 D->Value = Record.readAPValue();
1569
1570 // Add this to the AST context's lookup structure, and merge if needed.
1571 if (UnnamedGlobalConstantDecl *Existing =
1572 Reader.getContext().UnnamedGlobalConstantDecls.GetOrInsertNode(D))
1573 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1574}
1575
1578 D->Value = Record.readAPValue();
1579
1580 // Add this template parameter object to the AST context's lookup structure,
1581 // and merge if needed.
1582 if (TemplateParamObjectDecl *Existing =
1583 Reader.getContext().TemplateParamObjectDecls.GetOrInsertNode(D))
1584 Reader.getContext().setPrimaryMergedDecl(D, Existing->getCanonicalDecl());
1585}
1586
1588 VisitValueDecl(FD);
1589
1590 FD->ChainingSize = Record.readInt();
1591 assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1592 FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1593
1594 for (unsigned I = 0; I != FD->ChainingSize; ++I)
1595 FD->Chaining[I] = readDeclAs<NamedDecl>();
1596
1597 mergeMergeable(FD);
1598}
1599
1601 RedeclarableResult Redecl = VisitRedeclarable(VD);
1603
1604 BitsUnpacker VarDeclBits(Record.readInt());
1605 auto VarLinkage = Linkage(VarDeclBits.getNextBits(/*Width=*/3));
1606 bool DefGeneratedInModule = VarDeclBits.getNextBit();
1607 VD->VarDeclBits.SClass = (StorageClass)VarDeclBits.getNextBits(/*Width=*/3);
1608 VD->VarDeclBits.TSCSpec = VarDeclBits.getNextBits(/*Width=*/2);
1609 VD->VarDeclBits.InitStyle = VarDeclBits.getNextBits(/*Width=*/2);
1610 VD->VarDeclBits.ARCPseudoStrong = VarDeclBits.getNextBit();
1611 bool HasDeducedType = false;
1612 if (!isa<ParmVarDecl>(VD)) {
1613 VD->NonParmVarDeclBits.IsThisDeclarationADemotedDefinition =
1614 VarDeclBits.getNextBit();
1615 VD->NonParmVarDeclBits.ExceptionVar = VarDeclBits.getNextBit();
1616 VD->NonParmVarDeclBits.NRVOVariable = VarDeclBits.getNextBit();
1617 VD->NonParmVarDeclBits.CXXForRangeDecl = VarDeclBits.getNextBit();
1618
1619 VD->NonParmVarDeclBits.IsInline = VarDeclBits.getNextBit();
1620 VD->NonParmVarDeclBits.IsInlineSpecified = VarDeclBits.getNextBit();
1621 VD->NonParmVarDeclBits.IsConstexpr = VarDeclBits.getNextBit();
1622 VD->NonParmVarDeclBits.IsInitCapture = VarDeclBits.getNextBit();
1623 VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope =
1624 VarDeclBits.getNextBit();
1625
1626 VD->NonParmVarDeclBits.EscapingByref = VarDeclBits.getNextBit();
1627 HasDeducedType = VarDeclBits.getNextBit();
1628 VD->NonParmVarDeclBits.ImplicitParamKind =
1629 VarDeclBits.getNextBits(/*Width*/ 3);
1630
1631 VD->NonParmVarDeclBits.ObjCForDecl = VarDeclBits.getNextBit();
1632 }
1633
1634 // If this variable has a deduced type, defer reading that type until we are
1635 // done deserializing this variable, because the type might refer back to the
1636 // variable.
1637 if (HasDeducedType)
1638 Reader.PendingDeducedVarTypes.push_back({VD, DeferredTypeID});
1639 else
1640 VD->setType(Reader.GetType(DeferredTypeID));
1641 DeferredTypeID = 0;
1642
1643 VD->setCachedLinkage(VarLinkage);
1644
1645 // Reconstruct the one piece of the IdentifierNamespace that we need.
1646 if (VD->getStorageClass() == SC_Extern && VarLinkage != Linkage::None &&
1648 VD->setLocalExternDecl();
1649
1650 if (DefGeneratedInModule) {
1651 Reader.DefinitionSource[VD] =
1652 Loc.F->Kind == ModuleKind::MK_MainFile ||
1653 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
1654 }
1655
1656 if (VD->hasAttr<BlocksAttr>()) {
1657 Expr *CopyExpr = Record.readExpr();
1658 if (CopyExpr)
1659 Reader.getContext().setBlockVarCopyInit(VD, CopyExpr, Record.readInt());
1660 }
1661
1662 enum VarKind {
1663 VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1664 };
1665 switch ((VarKind)Record.readInt()) {
1666 case VarNotTemplate:
1667 // Only true variables (not parameters or implicit parameters) can be
1668 // merged; the other kinds are not really redeclarable at all.
1669 if (!isa<ParmVarDecl>(VD) && !isa<ImplicitParamDecl>(VD) &&
1670 !isa<VarTemplateSpecializationDecl>(VD))
1671 mergeRedeclarable(VD, Redecl);
1672 break;
1673 case VarTemplate:
1674 // Merged when we merge the template.
1675 VD->setDescribedVarTemplate(readDeclAs<VarTemplateDecl>());
1676 break;
1677 case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1678 auto *Tmpl = readDeclAs<VarDecl>();
1679 auto TSK = (TemplateSpecializationKind)Record.readInt();
1680 SourceLocation POI = readSourceLocation();
1681 Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1682 mergeRedeclarable(VD, Redecl);
1683 break;
1684 }
1685 }
1686
1687 return Redecl;
1688}
1689
1691 if (uint64_t Val = Record.readInt()) {
1692 EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1693 Eval->HasConstantInitialization = (Val & 2) != 0;
1694 Eval->HasConstantDestruction = (Val & 4) != 0;
1695 Eval->WasEvaluated = (Val & 8) != 0;
1696 if (Eval->WasEvaluated) {
1697 Eval->Evaluated = Record.readAPValue();
1698 if (Eval->Evaluated.needsCleanup())
1699 Reader.getContext().addDestruction(&Eval->Evaluated);
1700 }
1701
1702 // Store the offset of the initializer. Don't deserialize it yet: it might
1703 // not be needed, and might refer back to the variable, for example if it
1704 // contains a lambda.
1705 Eval->Value = GetCurrentCursorOffset();
1706 }
1707}
1708
1710 VisitVarDecl(PD);
1711}
1712
1714 VisitVarDecl(PD);
1715
1716 unsigned scopeIndex = Record.readInt();
1717 BitsUnpacker ParmVarDeclBits(Record.readInt());
1718 unsigned isObjCMethodParam = ParmVarDeclBits.getNextBit();
1719 unsigned scopeDepth = ParmVarDeclBits.getNextBits(/*Width=*/7);
1720 unsigned declQualifier = ParmVarDeclBits.getNextBits(/*Width=*/7);
1721 if (isObjCMethodParam) {
1722 assert(scopeDepth == 0);
1723 PD->setObjCMethodScopeInfo(scopeIndex);
1724 PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1725 } else {
1726 PD->setScopeInfo(scopeDepth, scopeIndex);
1727 }
1728 PD->ParmVarDeclBits.IsKNRPromoted = ParmVarDeclBits.getNextBit();
1729
1730 PD->ParmVarDeclBits.HasInheritedDefaultArg = ParmVarDeclBits.getNextBit();
1731 if (ParmVarDeclBits.getNextBit()) // hasUninstantiatedDefaultArg.
1732 PD->setUninstantiatedDefaultArg(Record.readExpr());
1733
1734 if (ParmVarDeclBits.getNextBit()) // Valid explicit object parameter
1735 PD->ExplicitObjectParameterIntroducerLoc = Record.readSourceLocation();
1736
1737 // FIXME: If this is a redeclaration of a function from another module, handle
1738 // inheritance of default arguments.
1739}
1740
1742 VisitVarDecl(DD);
1743 auto **BDs = DD->getTrailingObjects<BindingDecl *>();
1744 for (unsigned I = 0; I != DD->NumBindings; ++I) {
1745 BDs[I] = readDeclAs<BindingDecl>();
1746 BDs[I]->setDecomposedDecl(DD);
1747 }
1748}
1749
1751 VisitValueDecl(BD);
1752 BD->Binding = Record.readExpr();
1753}
1754
1756 VisitDecl(AD);
1757 AD->setAsmString(cast<StringLiteral>(Record.readExpr()));
1758 AD->setRParenLoc(readSourceLocation());
1759}
1760
1762 VisitDecl(D);
1763 D->Statement = Record.readStmt();
1764}
1765
1767 VisitDecl(BD);
1768 BD->setBody(cast_or_null<CompoundStmt>(Record.readStmt()));
1769 BD->setSignatureAsWritten(readTypeSourceInfo());
1770 unsigned NumParams = Record.readInt();
1772 Params.reserve(NumParams);
1773 for (unsigned I = 0; I != NumParams; ++I)
1774 Params.push_back(readDeclAs<ParmVarDecl>());
1775 BD->setParams(Params);
1776
1777 BD->setIsVariadic(Record.readInt());
1778 BD->setBlockMissingReturnType(Record.readInt());
1779 BD->setIsConversionFromLambda(Record.readInt());
1780 BD->setDoesNotEscape(Record.readInt());
1781 BD->setCanAvoidCopyToHeap(Record.readInt());
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<VarDecl>();
1789 unsigned flags = Record.readInt();
1790 bool byRef = (flags & 1);
1791 bool nested = (flags & 2);
1792 Expr *copyExpr = ((flags & 4) ? Record.readExpr() : nullptr);
1793
1794 captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1795 }
1796 BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
1797}
1798
1800 // NumParams is deserialized by OutlinedFunctionDecl::CreateDeserialized().
1801 VisitDecl(D);
1802 for (unsigned I = 0; I < D->NumParams; ++I)
1803 D->setParam(I, readDeclAs<ImplicitParamDecl>());
1804 D->setNothrow(Record.readInt() != 0);
1805 D->setBody(cast_or_null<Stmt>(Record.readStmt()));
1806}
1807
1809 VisitDecl(CD);
1810 unsigned ContextParamPos = Record.readInt();
1811 CD->setNothrow(Record.readInt() != 0);
1812 // Body is set by VisitCapturedStmt.
1813 for (unsigned I = 0; I < CD->NumParams; ++I) {
1814 if (I != ContextParamPos)
1815 CD->setParam(I, readDeclAs<ImplicitParamDecl>());
1816 else
1817 CD->setContextParam(I, readDeclAs<ImplicitParamDecl>());
1818 }
1819}
1820
1822 VisitDecl(D);
1823 D->setLanguage(static_cast<LinkageSpecLanguageIDs>(Record.readInt()));
1824 D->setExternLoc(readSourceLocation());
1825 D->setRBraceLoc(readSourceLocation());
1826}
1827
1829 VisitDecl(D);
1830 D->RBraceLoc = readSourceLocation();
1831}
1832
1835 D->setLocStart(readSourceLocation());
1836}
1837
1839 RedeclarableResult Redecl = VisitRedeclarable(D);
1841
1842 BitsUnpacker NamespaceDeclBits(Record.readInt());
1843 D->setInline(NamespaceDeclBits.getNextBit());
1844 D->setNested(NamespaceDeclBits.getNextBit());
1845 D->LocStart = readSourceLocation();
1846 D->RBraceLoc = readSourceLocation();
1847
1848 // Defer loading the anonymous namespace until we've finished merging
1849 // this namespace; loading it might load a later declaration of the
1850 // same namespace, and we have an invariant that older declarations
1851 // get merged before newer ones try to merge.
1852 GlobalDeclID AnonNamespace;
1853 if (Redecl.getFirstID() == ThisDeclID)
1854 AnonNamespace = readDeclID();
1855
1856 mergeRedeclarable(D, Redecl);
1857
1858 if (AnonNamespace.isValid()) {
1859 // Each module has its own anonymous namespace, which is disjoint from
1860 // any other module's anonymous namespaces, so don't attach the anonymous
1861 // namespace at all.
1862 auto *Anon = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));
1863 if (!Record.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
1883 RedeclarableResult Redecl = VisitRedeclarable(D);
1885 D->NamespaceLoc = readSourceLocation();
1886 D->IdentLoc = readSourceLocation();
1887 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1888 D->Namespace = readDeclAs<NamedDecl>();
1889 mergeRedeclarable(D, Redecl);
1890}
1891
1894 D->setUsingLoc(readSourceLocation());
1895 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1896 D->DNLoc = Record.readDeclarationNameLoc(D->getDeclName());
1897 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1898 D->setTypename(Record.readInt());
1899 if (auto *Pattern = readDeclAs<NamedDecl>())
1900 Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1902}
1903
1906 D->setUsingLoc(readSourceLocation());
1907 D->setEnumLoc(readSourceLocation());
1908 D->setEnumType(Record.readTypeSourceInfo());
1909 D->FirstUsingShadow.setPointer(readDeclAs<UsingShadowDecl>());
1910 if (auto *Pattern = readDeclAs<UsingEnumDecl>())
1913}
1914
1917 D->InstantiatedFrom = readDeclAs<NamedDecl>();
1918 auto **Expansions = D->getTrailingObjects<NamedDecl *>();
1919 for (unsigned I = 0; I != D->NumExpansions; ++I)
1920 Expansions[I] = readDeclAs<NamedDecl>();
1922}
1923
1925 RedeclarableResult Redecl = VisitRedeclarable(D);
1927 D->Underlying = readDeclAs<NamedDecl>();
1928 D->IdentifierNamespace = Record.readInt();
1929 D->UsingOrNextShadow = readDeclAs<NamedDecl>();
1930 auto *Pattern = readDeclAs<UsingShadowDecl>();
1931 if (Pattern)
1933 mergeRedeclarable(D, Redecl);
1934}
1935
1939 D->NominatedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1940 D->ConstructedBaseClassShadowDecl = readDeclAs<ConstructorUsingShadowDecl>();
1941 D->IsVirtual = Record.readInt();
1942}
1943
1946 D->UsingLoc = readSourceLocation();
1947 D->NamespaceLoc = readSourceLocation();
1948 D->QualifierLoc = Record.readNestedNameSpecifierLoc();
1949 D->NominatedNamespace = readDeclAs<NamedDecl>();
1950 D->CommonAncestor = readDeclAs<DeclContext>();
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(
1977 struct CXXRecordDecl::DefinitionData &Data, const CXXRecordDecl *D,
1978 Decl *LambdaContext, unsigned IndexInLambdaContext) {
1979
1980 BitsUnpacker CXXRecordDeclBits = Record.readInt();
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 // Note: the caller has deserialized the IsLambda bit already.
1991 Data.ODRHash = Record.readInt();
1992 Data.HasODRHash = true;
1993
1994 if (Record.readInt()) {
1995 Reader.DefinitionSource[D] =
1996 Loc.F->Kind == ModuleKind::MK_MainFile ||
1997 Reader.getContext().getLangOpts().BuildingPCHWithObjectFile;
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 (!Data.IsLambda) {
2007 assert(!LambdaContext && !IndexInLambdaContext &&
2008 "given lambda context for non-lambda");
2009
2010 Data.NumBases = Record.readInt();
2011 if (Data.NumBases)
2012 Data.Bases = ReadGlobalOffset();
2013
2014 Data.NumVBases = Record.readInt();
2015 if (Data.NumVBases)
2016 Data.VBases = ReadGlobalOffset();
2017
2018 Data.FirstFriend = readDeclID().getRawValue();
2019 } else {
2020 using Capture = LambdaCapture;
2021
2022 auto &Lambda = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
2023
2024 BitsUnpacker LambdaBits(Record.readInt());
2025 Lambda.DependencyKind = LambdaBits.getNextBits(/*Width=*/2);
2026 Lambda.IsGenericLambda = LambdaBits.getNextBit();
2027 Lambda.CaptureDefault = LambdaBits.getNextBits(/*Width=*/2);
2028 Lambda.NumCaptures = LambdaBits.getNextBits(/*Width=*/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) {
2039 ToCapture = (Capture *)Reader.getContext().Allocate(sizeof(Capture) *
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) {
2045 SourceLocation Loc = readSourceLocation();
2046 BitsUnpacker CaptureBits(Record.readInt());
2047 bool IsImplicit = CaptureBits.getNextBit();
2048 auto Kind =
2049 static_cast<LambdaCaptureKind>(CaptureBits.getNextBits(/*Width=*/3));
2050 switch (Kind) {
2051 case LCK_StarThis:
2052 case LCK_This:
2053 case LCK_VLAType:
2054 new (ToCapture)
2055 Capture(Loc, IsImplicit, Kind, nullptr, SourceLocation());
2056 ToCapture++;
2057 break;
2058 case LCK_ByCopy:
2059 case LCK_ByRef:
2060 auto *Var = readDeclAs<ValueDecl>();
2061 SourceLocation EllipsisLoc = readSourceLocation();
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 // Track that we merged the definitions.
2078 Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
2079 DD.Definition));
2080 Reader.PendingDefinitions.erase(MergeDD.Definition);
2081 MergeDD.Definition->demoteThisDefinitionToDeclaration();
2082 Reader.mergeDefinitionVisibility(DD.Definition, MergeDD.Definition);
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 // We faked up this definition data because we found a class for which we'd
2091 // not yet loaded the definition. Replace it with the real thing now.
2092 assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");
2093 PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
2094
2095 // Don't change which declaration is the definition; that is required
2096 // to be invariant once we select it.
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"
2111 NO_MERGE(IsLambda)
2112 #undef NO_MERGE
2113 #undef MERGE_OR
2114
2115 if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
2116 DetectedOdrViolation = true;
2117 // FIXME: Issue a diagnostic if the base classes don't match when we come
2118 // to lazily load them.
2119
2120 // FIXME: Issue a diagnostic if the list of conversion functions doesn't
2121 // match when we come to lazily load them.
2122 if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
2123 DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
2124 DD.ComputedVisibleConversions = true;
2125 }
2126
2127 // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
2128 // lazily load it.
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];
2147 DetectedOdrViolation |= Cap1.getCaptureKind() != Cap2.getCaptureKind();
2148 }
2149 Lambda1.AddCaptureList(Reader.getContext(), Lambda2.Captures.front());
2150 }
2151 }
2152
2153 // We don't want to check ODR for decls in the global module fragment.
2154 if (shouldSkipCheckingODR(MergeDD.Definition) || shouldSkipCheckingODR(D))
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
2166void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update,
2167 Decl *LambdaContext,
2168 unsigned IndexInLambdaContext) {
2169 struct CXXRecordDecl::DefinitionData *DD;
2170 ASTContext &C = Reader.getContext();
2171
2172 // Determine whether this is a lambda closure type, so that we can
2173 // allocate the appropriate DefinitionData structure.
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(
2179 D, nullptr, CXXRecordDecl::LDK_Unknown, false, LCD_None);
2180 else
2181 DD = new (C) struct CXXRecordDecl::DefinitionData(D);
2182
2183 CXXRecordDecl *Canon = D->getCanonicalDecl();
2184 // Set decl definition data before reading it, so that during deserialization
2185 // when we read CXXRecordDecl, it already has definition data and we don't
2186 // set fake one.
2187 if (!Canon->DefinitionData)
2188 Canon->DefinitionData = DD;
2189 D->DefinitionData = Canon->DefinitionData;
2190 ReadCXXDefinitionData(*DD, D, LambdaContext, IndexInLambdaContext);
2191
2192 // Mark this declaration as being a definition.
2193 D->setCompleteDefinition(true);
2194
2195 // We might already have a different definition for this record. This can
2196 // happen either because we're reading an update record, or because we've
2197 // already done some merging. Either way, just merge into it.
2198 if (Canon->DefinitionData != DD) {
2199 MergeImpl.MergeDefinitionData(Canon, std::move(*DD));
2200 return;
2201 }
2202
2203 // If this is not the first declaration or is an update record, we can have
2204 // other redeclarations already. Make a note that we need to propagate the
2205 // DefinitionData pointer onto them.
2206 if (Update || Canon != D)
2207 Reader.PendingDefinitions.insert(D);
2208}
2209
2211 RedeclarableResult Redecl = VisitRecordDeclImpl(D);
2212
2213 ASTContext &C = Reader.getContext();
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 // Merged when we merge the folding set entry in the primary template.
2228 if (!isa<ClassTemplateSpecializationDecl>(D))
2229 mergeRedeclarable(D, Redecl);
2230 break;
2231 case CXXRecTemplate: {
2232 // Merged when we merge the template.
2233 auto *Template = readDeclAs<ClassTemplateDecl>();
2234 D->TemplateOrInstantiation = Template;
2235 if (!Template->getTemplatedDecl()) {
2236 // We've not actually loaded the ClassTemplateDecl yet, because we're
2237 // currently being loaded as its pattern. Rely on it to set up our
2238 // TypeForDecl (see VisitClassTemplateDecl).
2239 //
2240 // Beware: we do not yet know our canonical declaration, and may still
2241 // get merged once the surrounding class template has got off the ground.
2242 DeferredTypeID = 0;
2243 }
2244 break;
2245 }
2246 case CXXRecMemberSpecialization: {
2247 auto *RD = readDeclAs<CXXRecordDecl>();
2248 auto TSK = (TemplateSpecializationKind)Record.readInt();
2249 SourceLocation POI = readSourceLocation();
2251 MSI->setPointOfInstantiation(POI);
2252 D->TemplateOrInstantiation = MSI;
2253 mergeRedeclarable(D, Redecl);
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 // If we don't have a mangling context, treat this like any other
2264 // declaration.
2265 mergeRedeclarable(D, Redecl);
2266 break;
2267 }
2268 }
2269
2270 bool WasDefinition = Record.readInt();
2271 if (WasDefinition)
2272 ReadCXXRecordDefinition(D, /*Update=*/false, LambdaContext,
2273 IndexInLambdaContext);
2274 else
2275 // Propagate DefinitionData pointer from the canonical declaration.
2276 D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
2277
2278 // Lazily load the key function to avoid deserializing every method so we can
2279 // compute it.
2280 if (WasDefinition) {
2281 GlobalDeclID KeyFn = readDeclID();
2282 if (KeyFn.isValid() && D->isCompleteDefinition())
2283 // FIXME: This is wrong for the ARM ABI, where some other module may have
2284 // made this function no longer be a key function. We need an update
2285 // record or similar for that case.
2286 C.KeyFunctions[D] = KeyFn.getRawValue();
2287 }
2288
2289 return Redecl;
2290}
2291
2293 D->setExplicitSpecifier(Record.readExplicitSpec());
2294 D->Ctor = readDeclAs<CXXConstructorDecl>();
2296 D->setDeductionCandidateKind(
2297 static_cast<DeductionCandidate>(Record.readInt()));
2298 D->setSourceDeductionGuide(readDeclAs<CXXDeductionGuideDecl>());
2299 D->setSourceDeductionGuideKind(
2301 Record.readInt()));
2302}
2303
2306
2307 unsigned NumOverridenMethods = Record.readInt();
2308 if (D->isCanonicalDecl()) {
2309 while (NumOverridenMethods--) {
2310 // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
2311 // MD may be initializing.
2312 if (auto *MD = readDeclAs<CXXMethodDecl>())
2314 }
2315 } else {
2316 // We don't care about which declarations this used to override; we get
2317 // the relevant information from the canonical declaration.
2318 Record.skipInts(NumOverridenMethods);
2319 }
2320}
2321
2323 // We need the inherited constructor information to merge the declaration,
2324 // so we have to read it before we call VisitCXXMethodDecl.
2325 D->setExplicitSpecifier(Record.readExplicitSpec());
2326 if (D->isInheritingConstructor()) {
2327 auto *Shadow = readDeclAs<ConstructorUsingShadowDecl>();
2328 auto *Ctor = readDeclAs<CXXConstructorDecl>();
2329 *D->getTrailingObjects<InheritedConstructor>() =
2330 InheritedConstructor(Shadow, Ctor);
2331 }
2332
2334}
2335
2338
2339 if (auto *OperatorDelete = readDeclAs<FunctionDecl>()) {
2341 auto *ThisArg = Record.readExpr();
2342 // FIXME: Check consistency if we have an old and new operator delete.
2343 if (!Canon->OperatorDelete) {
2344 Canon->OperatorDelete = OperatorDelete;
2345 Canon->OperatorDeleteThisArg = ThisArg;
2346 }
2347 }
2348}
2349
2351 D->setExplicitSpecifier(Record.readExplicitSpec());
2353}
2354
2356 VisitDecl(D);
2357 D->ImportedModule = readModule();
2358 D->setImportComplete(Record.readInt());
2359 auto *StoredLocs = D->getTrailingObjects<SourceLocation>();
2360 for (unsigned I = 0, N = Record.back(); I != N; ++I)
2361 StoredLocs[I] = readSourceLocation();
2362 Record.skipInts(1); // The number of stored source locations.
2363}
2364
2366 VisitDecl(D);
2367 D->setColonLoc(readSourceLocation());
2368}
2369
2371 VisitDecl(D);
2372 if (Record.readInt()) // hasFriendDecl
2373 D->Friend = readDeclAs<NamedDecl>();
2374 else
2375 D->Friend = readTypeSourceInfo();
2376 for (unsigned i = 0; i != D->NumTPLists; ++i)
2377 D->getTrailingObjects<TemplateParameterList *>()[i] =
2378 Record.readTemplateParameterList();
2379 D->NextFriend = readDeclID().getRawValue();
2380 D->UnsupportedFriend = (Record.readInt() != 0);
2381 D->FriendLoc = readSourceLocation();
2382 D->EllipsisLoc = readSourceLocation();
2383}
2384
2386 VisitDecl(D);
2387 unsigned NumParams = Record.readInt();
2388 D->NumParams = NumParams;
2389 D->Params = new (Reader.getContext()) TemplateParameterList *[NumParams];
2390 for (unsigned i = 0; i != NumParams; ++i)
2391 D->Params[i] = Record.readTemplateParameterList();
2392 if (Record.readInt()) // HasFriendDecl
2393 D->Friend = readDeclAs<NamedDecl>();
2394 else
2395 D->Friend = readTypeSourceInfo();
2396 D->FriendLoc = readSourceLocation();
2397}
2398
2401
2402 assert(!D->TemplateParams && "TemplateParams already set!");
2403 D->TemplateParams = Record.readTemplateParameterList();
2404 D->init(readDeclAs<NamedDecl>());
2405}
2406
2409 D->ConstraintExpr = Record.readExpr();
2411}
2412
2415 // The size of the template list was read during creation of the Decl, so we
2416 // don't have to re-read it here.
2417 VisitDecl(D);
2419 for (unsigned I = 0; I < D->NumTemplateArgs; ++I)
2420 Args.push_back(Record.readTemplateArgument(/*Canonicalize=*/true));
2421 D->setTemplateArguments(Args);
2422}
2423
2425}
2426
2428 llvm::BitstreamCursor &DeclsCursor,
2429 bool IsPartial) {
2430 uint64_t Offset = ReadLocalOffset();
2431 bool Failed =
2432 Reader.ReadSpecializations(M, DeclsCursor, Offset, D, IsPartial);
2433 (void)Failed;
2434 assert(!Failed);
2435}
2436
2437RedeclarableResult
2439 RedeclarableResult Redecl = VisitRedeclarable(D);
2440
2441 // Make sure we've allocated the Common pointer first. We do this before
2442 // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
2444 if (!CanonD->Common) {
2445 CanonD->Common = CanonD->newCommon(Reader.getContext());
2446 Reader.PendingDefinitions.insert(CanonD);
2447 }
2448 D->Common = CanonD->Common;
2449
2450 // If this is the first declaration of the template, fill in the information
2451 // for the 'common' pointer.
2452 if (ThisDeclID == Redecl.getFirstID()) {
2453 if (auto *RTD = readDeclAs<RedeclarableTemplateDecl>()) {
2454 assert(RTD->getKind() == D->getKind() &&
2455 "InstantiatedFromMemberTemplate kind mismatch");
2456 D->setInstantiatedFromMemberTemplate(RTD);
2457 if (Record.readInt())
2458 D->setMemberSpecialization();
2459 }
2460 }
2461
2463 D->IdentifierNamespace = Record.readInt();
2464
2465 return Redecl;
2466}
2467
2469 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2471
2472 if (ThisDeclID == Redecl.getFirstID()) {
2473 // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
2474 // the specializations.
2475 ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);
2476 ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/true);
2477 }
2478
2479 if (D->getTemplatedDecl()->TemplateOrInstantiation) {
2480 // We were loaded before our templated declaration was. We've not set up
2481 // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
2482 // it now.
2484 D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
2485 }
2486}
2487
2489 llvm_unreachable("BuiltinTemplates are not serialized");
2490}
2491
2492/// TODO: Unify with ClassTemplateDecl version?
2493/// May require unifying ClassTemplateDecl and
2494/// VarTemplateDecl beyond TemplateDecl...
2496 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2498
2499 if (ThisDeclID == Redecl.getFirstID()) {
2500 // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
2501 // the specializations.
2502 ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);
2503 ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/true);
2504 }
2505}
2506
2509 RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
2510
2511 ASTContext &C = Reader.getContext();
2512 if (Decl *InstD = readDecl()) {
2513 if (auto *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
2514 D->SpecializedTemplate = CTD;
2515 } else {
2517 Record.readTemplateArgumentList(TemplArgs);
2518 TemplateArgumentList *ArgList
2519 = TemplateArgumentList::CreateCopy(C, TemplArgs);
2520 auto *PS =
2522 SpecializedPartialSpecialization();
2523 PS->PartialSpecialization
2524 = cast<ClassTemplatePartialSpecializationDecl>(InstD);
2525 PS->TemplateArgs = ArgList;
2526 D->SpecializedTemplate = PS;
2527 }
2528 }
2529
2531 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
2532 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2533 D->PointOfInstantiation = readSourceLocation();
2534 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2535
2536 bool writtenAsCanonicalDecl = Record.readInt();
2537 if (writtenAsCanonicalDecl) {
2538 auto *CanonPattern = readDeclAs<ClassTemplateDecl>();
2539 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2540 // Set this as, or find, the canonical declaration for this specialization
2542 if (auto *Partial = dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
2543 CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
2544 .GetOrInsertNode(Partial);
2545 } else {
2546 CanonSpec =
2547 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2548 }
2549 // If there was already a canonical specialization, merge into it.
2550 if (CanonSpec != D) {
2551 MergeImpl.mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
2552
2553 // This declaration might be a definition. Merge with any existing
2554 // definition.
2555 if (auto *DDD = D->DefinitionData) {
2556 if (CanonSpec->DefinitionData)
2557 MergeImpl.MergeDefinitionData(CanonSpec, std::move(*DDD));
2558 else
2559 CanonSpec->DefinitionData = D->DefinitionData;
2560 }
2561 D->DefinitionData = CanonSpec->DefinitionData;
2562 }
2563 }
2564 }
2565
2566 // extern/template keyword locations for explicit instantiations
2567 if (Record.readBool()) {
2568 auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;
2569 ExplicitInfo->ExternKeywordLoc = readSourceLocation();
2570 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2571 D->ExplicitInfo = ExplicitInfo;
2572 }
2573
2574 if (Record.readBool())
2575 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2576
2577 return Redecl;
2578}
2579
2582 // We need to read the template params first because redeclarable is going to
2583 // need them for profiling
2584 TemplateParameterList *Params = Record.readTemplateParameterList();
2585 D->TemplateParams = Params;
2586
2587 RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2588
2589 // These are read/set from/to the first declaration.
2590 if (ThisDeclID == Redecl.getFirstID()) {
2591 D->InstantiatedFromMember.setPointer(
2592 readDeclAs<ClassTemplatePartialSpecializationDecl>());
2593 D->InstantiatedFromMember.setInt(Record.readInt());
2594 }
2595}
2596
2598 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2599
2600 if (ThisDeclID == Redecl.getFirstID()) {
2601 // This FunctionTemplateDecl owns a CommonPtr; read it.
2602 ReadSpecializations(*Loc.F, D, Loc.F->DeclsCursor, /*IsPartial=*/false);
2603 }
2604}
2605
2606/// TODO: Unify with ClassTemplateSpecializationDecl version?
2607/// May require unifying ClassTemplate(Partial)SpecializationDecl and
2608/// VarTemplate(Partial)SpecializationDecl with a new data
2609/// structure Template(Partial)SpecializationDecl, and
2610/// using Template(Partial)SpecializationDecl as input type.
2613 ASTContext &C = Reader.getContext();
2614 if (Decl *InstD = readDecl()) {
2615 if (auto *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
2616 D->SpecializedTemplate = VTD;
2617 } else {
2619 Record.readTemplateArgumentList(TemplArgs);
2621 C, TemplArgs);
2622 auto *PS =
2623 new (C)
2624 VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2625 PS->PartialSpecialization =
2626 cast<VarTemplatePartialSpecializationDecl>(InstD);
2627 PS->TemplateArgs = ArgList;
2628 D->SpecializedTemplate = PS;
2629 }
2630 }
2631
2632 // extern/template keyword locations for explicit instantiations
2633 if (Record.readBool()) {
2634 auto *ExplicitInfo = new (C) ExplicitInstantiationInfo;
2635 ExplicitInfo->ExternKeywordLoc = readSourceLocation();
2636 ExplicitInfo->TemplateKeywordLoc = readSourceLocation();
2637 D->ExplicitInfo = ExplicitInfo;
2638 }
2639
2640 if (Record.readBool())
2641 D->setTemplateArgsAsWritten(Record.readASTTemplateArgumentListInfo());
2642
2644 Record.readTemplateArgumentList(TemplArgs, /*Canonicalize*/ true);
2645 D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2646 D->PointOfInstantiation = readSourceLocation();
2647 D->SpecializationKind = (TemplateSpecializationKind)Record.readInt();
2648 D->IsCompleteDefinition = Record.readInt();
2649
2650 RedeclarableResult Redecl = VisitVarDeclImpl(D);
2651
2652 bool writtenAsCanonicalDecl = Record.readInt();
2653 if (writtenAsCanonicalDecl) {
2654 auto *CanonPattern = readDeclAs<VarTemplateDecl>();
2655 if (D->isCanonicalDecl()) { // It's kept in the folding set.
2657 if (auto *Partial = dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
2658 CanonSpec = CanonPattern->getCommonPtr()
2659 ->PartialSpecializations.GetOrInsertNode(Partial);
2660 } else {
2661 CanonSpec =
2662 CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2663 }
2664 // If we already have a matching specialization, merge it.
2665 if (CanonSpec != D)
2666 MergeImpl.mergeRedeclarable<VarDecl>(D, CanonSpec, Redecl);
2667 }
2668 }
2669
2670 return Redecl;
2671}
2672
2673/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2674/// May require unifying ClassTemplate(Partial)SpecializationDecl and
2675/// VarTemplate(Partial)SpecializationDecl with a new data
2676/// structure Template(Partial)SpecializationDecl, and
2677/// using Template(Partial)SpecializationDecl as input type.
2680 TemplateParameterList *Params = Record.readTemplateParameterList();
2681 D->TemplateParams = Params;
2682
2683 RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2684
2685 // These are read/set from/to the first declaration.
2686 if (ThisDeclID == Redecl.getFirstID()) {
2687 D->InstantiatedFromMember.setPointer(
2688 readDeclAs<VarTemplatePartialSpecializationDecl>());
2689 D->InstantiatedFromMember.setInt(Record.readInt());
2690 }
2691}
2692
2695
2696 D->setDeclaredWithTypename(Record.readInt());
2697
2698 bool TypeConstraintInitialized = D->hasTypeConstraint() && Record.readBool();
2699 if (TypeConstraintInitialized) {
2700 ConceptReference *CR = nullptr;
2701 if (Record.readBool())
2702 CR = Record.readConceptReference();
2703 Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
2704
2705 D->setTypeConstraint(CR, ImmediatelyDeclaredConstraint);
2706 if ((D->ExpandedParameterPack = Record.readInt()))
2707 D->NumExpanded = Record.readInt();
2708 }
2709
2710 if (Record.readInt())
2711 D->setDefaultArgument(Reader.getContext(),
2712 Record.readTemplateArgumentLoc());
2713}
2714
2717 // TemplateParmPosition.
2718 D->setDepth(Record.readInt());
2719 D->setPosition(Record.readInt());
2720 if (D->hasPlaceholderTypeConstraint())
2721 D->setPlaceholderTypeConstraint(Record.readExpr());
2722 if (D->isExpandedParameterPack()) {
2723 auto TypesAndInfos =
2724 D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2725 for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2726 new (&TypesAndInfos[I].first) QualType(Record.readType());
2727 TypesAndInfos[I].second = readTypeSourceInfo();
2728 }
2729 } else {
2730 // Rest of NonTypeTemplateParmDecl.
2731 D->ParameterPack = Record.readInt();
2732 if (Record.readInt())
2733 D->setDefaultArgument(Reader.getContext(),
2734 Record.readTemplateArgumentLoc());
2735 }
2736}
2737
2740 D->setDeclaredWithTypename(Record.readBool());
2741 // TemplateParmPosition.
2742 D->setDepth(Record.readInt());
2743 D->setPosition(Record.readInt());
2744 if (D->isExpandedParameterPack()) {
2745 auto **Data = D->getTrailingObjects<TemplateParameterList *>();
2746 for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2747 I != N; ++I)
2748 Data[I] = Record.readTemplateParameterList();
2749 } else {
2750 // Rest of TemplateTemplateParmDecl.
2751 D->ParameterPack = Record.readInt();
2752 if (Record.readInt())
2753 D->setDefaultArgument(Reader.getContext(),
2754 Record.readTemplateArgumentLoc());
2755 }
2756}
2757
2759 RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2761}
2762
2764 VisitDecl(D);
2765 D->AssertExprAndFailed.setPointer(Record.readExpr());
2766 D->AssertExprAndFailed.setInt(Record.readInt());
2767 D->Message = cast_or_null<StringLiteral>(Record.readExpr());
2768 D->RParenLoc = readSourceLocation();
2769}
2770
2772 VisitDecl(D);
2773}
2774
2777 VisitDecl(D);
2778 D->ExtendingDecl = readDeclAs<ValueDecl>();
2779 D->ExprWithTemporary = Record.readStmt();
2780 if (Record.readInt()) {
2781 D->Value = new (D->getASTContext()) APValue(Record.readAPValue());
2782 D->getASTContext().addDestruction(D->Value);
2783 }
2784 D->ManglingNumber = Record.readInt();
2786}
2787
2788void ASTDeclReader::VisitDeclContext(DeclContext *DC, uint64_t &LexicalOffset,
2789 uint64_t &VisibleOffset,
2790 uint64_t &ModuleLocalOffset,
2791 uint64_t &TULocalOffset) {
2792 LexicalOffset = ReadLocalOffset();
2793 VisibleOffset = ReadLocalOffset();
2794 ModuleLocalOffset = ReadLocalOffset();
2795 TULocalOffset = ReadLocalOffset();
2796}
2797
2798template <typename T>
2800 GlobalDeclID FirstDeclID = readDeclID();
2801 Decl *MergeWith = nullptr;
2802
2803 bool IsKeyDecl = ThisDeclID == FirstDeclID;
2804 bool IsFirstLocalDecl = false;
2805
2806 uint64_t RedeclOffset = 0;
2807
2808 // invalid FirstDeclID indicates that this declaration was the only
2809 // declaration of its entity, and is used for space optimization.
2810 if (FirstDeclID.isInvalid()) {
2811 FirstDeclID = ThisDeclID;
2812 IsKeyDecl = true;
2813 IsFirstLocalDecl = true;
2814 } else if (unsigned N = Record.readInt()) {
2815 // This declaration was the first local declaration, but may have imported
2816 // other declarations.
2817 IsKeyDecl = N == 1;
2818 IsFirstLocalDecl = true;
2819
2820 // We have some declarations that must be before us in our redeclaration
2821 // chain. Read them now, and remember that we ought to merge with one of
2822 // them.
2823 // FIXME: Provide a known merge target to the second and subsequent such
2824 // declaration.
2825 for (unsigned I = 0; I != N - 1; ++I)
2826 MergeWith = readDecl();
2827
2828 RedeclOffset = ReadLocalOffset();
2829 } else {
2830 // This declaration was not the first local declaration. Read the first
2831 // local declaration now, to trigger the import of other redeclarations.
2832 (void)readDecl();
2833 }
2834
2835 auto *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
2836 if (FirstDecl != D) {
2837 // We delay loading of the redeclaration chain to avoid deeply nested calls.
2838 // We temporarily set the first (canonical) declaration as the previous one
2839 // which is the one that matters and mark the real previous DeclID to be
2840 // loaded & attached later on.
2841 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
2842 D->First = FirstDecl->getCanonicalDecl();
2843 }
2844
2845 auto *DAsT = static_cast<T *>(D);
2846
2847 // Note that we need to load local redeclarations of this decl and build a
2848 // decl chain for them. This must happen *after* we perform the preloading
2849 // above; this ensures that the redeclaration chain is built in the correct
2850 // order.
2851 if (IsFirstLocalDecl)
2852 Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
2853
2854 return RedeclarableResult(MergeWith, FirstDeclID, IsKeyDecl);
2855}
2856
2857/// Attempts to merge the given declaration (D) with another declaration
2858/// of the same entity.
2859template <typename T>
2861 RedeclarableResult &Redecl) {
2862 // If modules are not available, there is no reason to perform this merge.
2863 if (!Reader.getContext().getLangOpts().Modules)
2864 return;
2865
2866 // If we're not the canonical declaration, we don't need to merge.
2867 if (!DBase->isFirstDecl())
2868 return;
2869
2870 auto *D = static_cast<T *>(DBase);
2871
2872 if (auto *Existing = Redecl.getKnownMergeTarget())
2873 // We already know of an existing declaration we should merge with.
2874 MergeImpl.mergeRedeclarable(D, cast<T>(Existing), Redecl);
2875 else if (FindExistingResult ExistingRes = findExisting(D))
2876 if (T *Existing = ExistingRes)
2877 MergeImpl.mergeRedeclarable(D, Existing, Redecl);
2878}
2879
2880/// Attempt to merge D with a previous declaration of the same lambda, which is
2881/// found by its index within its context declaration, if it has one.
2882///
2883/// We can't look up lambdas in their enclosing lexical or semantic context in
2884/// general, because for lambdas in variables, both of those might be a
2885/// namespace or the translation unit.
2886void ASTDeclMerger::mergeLambda(CXXRecordDecl *D, RedeclarableResult &Redecl,
2887 Decl &Context, unsigned IndexInContext) {
2888 // If modules are not available, there is no reason to perform this merge.
2889 if (!Reader.getContext().getLangOpts().Modules)
2890 return;
2891
2892 // If we're not the canonical declaration, we don't need to merge.
2893 if (!D->isFirstDecl())
2894 return;
2895
2896 if (auto *Existing = Redecl.getKnownMergeTarget())
2897 // We already know of an existing declaration we should merge with.
2898 mergeRedeclarable(D, cast<TagDecl>(Existing), Redecl);
2899
2900 // Look up this lambda to see if we've seen it before. If so, merge with the
2901 // one we already loaded.
2902 NamedDecl *&Slot = Reader.LambdaDeclarationsForMerging[{
2903 Context.getCanonicalDecl(), IndexInContext}];
2904 if (Slot)
2905 mergeRedeclarable(D, cast<TagDecl>(Slot), Redecl);
2906 else
2907 Slot = D;
2908}
2909
2911 RedeclarableResult &Redecl) {
2912 mergeRedeclarable(D, Redecl);
2913 // If we merged the template with a prior declaration chain, merge the
2914 // common pointer.
2915 // FIXME: Actually merge here, don't just overwrite.
2916 D->Common = D->getCanonicalDecl()->Common;
2917}
2918
2919/// "Cast" to type T, asserting if we don't have an implicit conversion.
2920/// We use this to put code in a template that will only be valid for certain
2921/// instantiations.
2922template<typename T> static T assert_cast(T t) { return t; }
2923template<typename T> static T assert_cast(...) {
2924 llvm_unreachable("bad assert_cast");
2925}
2926
2927/// Merge together the pattern declarations from two template
2928/// declarations.
2930 RedeclarableTemplateDecl *Existing,
2931 bool IsKeyDecl) {
2932 auto *DPattern = D->getTemplatedDecl();
2933 auto *ExistingPattern = Existing->getTemplatedDecl();
2934 RedeclarableResult Result(
2935 /*MergeWith*/ ExistingPattern,
2936 DPattern->getCanonicalDecl()->getGlobalID(), IsKeyDecl);
2937
2938 if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2939 // Merge with any existing definition.
2940 // FIXME: This is duplicated in several places. Refactor.
2941 auto *ExistingClass =
2942 cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2943 if (auto *DDD = DClass->DefinitionData) {
2944 if (ExistingClass->DefinitionData) {
2945 MergeDefinitionData(ExistingClass, std::move(*DDD));
2946 } else {
2947 ExistingClass->DefinitionData = DClass->DefinitionData;
2948 // We may have skipped this before because we thought that DClass
2949 // was the canonical declaration.
2950 Reader.PendingDefinitions.insert(DClass);
2951 }
2952 }
2953 DClass->DefinitionData = ExistingClass->DefinitionData;
2954
2955 return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2956 Result);
2957 }
2958 if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2959 return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2960 Result);
2961 if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2962 return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2963 if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
2964 return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
2965 Result);
2966 llvm_unreachable("merged an unknown kind of redeclarable template");
2967}
2968
2969/// Attempts to merge the given declaration (D) with another declaration
2970/// of the same entity.
2971template <typename T>
2973 GlobalDeclID KeyDeclID) {
2974 auto *D = static_cast<T *>(DBase);
2975 T *ExistingCanon = Existing->getCanonicalDecl();
2976 T *DCanon = D->getCanonicalDecl();
2977 if (ExistingCanon != DCanon) {
2978 // Have our redeclaration link point back at the canonical declaration
2979 // of the existing declaration, so that this declaration has the
2980 // appropriate canonical declaration.
2981 D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2982 D->First = ExistingCanon;
2983 ExistingCanon->Used |= D->Used;
2984 D->Used = false;
2985
2986 bool IsKeyDecl = KeyDeclID.isValid();
2987
2988 // When we merge a template, merge its pattern.
2989 if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2991 DTemplate, assert_cast<RedeclarableTemplateDecl *>(ExistingCanon),
2992 IsKeyDecl);
2993
2994 // If this declaration is a key declaration, make a note of that.
2995 if (IsKeyDecl)
2996 Reader.KeyDecls[ExistingCanon].push_back(KeyDeclID);
2997 }
2998}
2999
3000/// ODR-like semantics for C/ObjC allow us to merge tag types and a structural
3001/// check in Sema guarantees the types can be merged (see C11 6.2.7/1 or C89
3002/// 6.1.2.6/1). Although most merging is done in Sema, we need to guarantee
3003/// that some types are mergeable during deserialization, otherwise name
3004/// lookup fails. This is the case for EnumConstantDecl.
3006 if (!ND)
3007 return false;
3008 // TODO: implement merge for other necessary decls.
3009 if (isa<EnumConstantDecl, FieldDecl, IndirectFieldDecl>(ND))
3010 return true;
3011 return false;
3012}
3013
3014/// Attempts to merge LifetimeExtendedTemporaryDecl with
3015/// identical class definitions from two different modules.
3017 // If modules are not available, there is no reason to perform this merge.
3018 if (!Reader.getContext().getLangOpts().Modules)
3019 return;
3020
3022
3024 Reader.LETemporaryForMerging[std::make_pair(
3025 LETDecl->getExtendingDecl(), LETDecl->getManglingNumber())];
3026 if (LookupResult)
3027 Reader.getContext().setPrimaryMergedDecl(LETDecl,
3028 LookupResult->getCanonicalDecl());
3029 else
3030 LookupResult = LETDecl;
3031}
3032
3033/// Attempts to merge the given declaration (D) with another declaration
3034/// of the same entity, for the case where the entity is not actually
3035/// redeclarable. This happens, for instance, when merging the fields of
3036/// identical class definitions from two different modules.
3037template<typename T>
3039 // If modules are not available, there is no reason to perform this merge.
3040 if (!Reader.getContext().getLangOpts().Modules)
3041 return;
3042
3043 // ODR-based merging is performed in C++ and in some cases (tag types) in C.
3044 // Note that C identically-named things in different translation units are
3045 // not redeclarations, but may still have compatible types, where ODR-like
3046 // semantics may apply.
3047 if (!Reader.getContext().getLangOpts().CPlusPlus &&
3048 !allowODRLikeMergeInC(dyn_cast<NamedDecl>(static_cast<T*>(D))))
3049 return;
3050
3051 if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
3052 if (T *Existing = ExistingRes)
3053 Reader.getContext().setPrimaryMergedDecl(static_cast<T *>(D),
3054 Existing->getCanonicalDecl());
3055}
3056
3058 Record.readOMPChildren(D->Data);
3059 VisitDecl(D);
3060}
3061
3063 Record.readOMPChildren(D->Data);
3064 VisitDecl(D);
3065}
3066
3068 Record.readOMPChildren(D->Data);
3069 VisitDecl(D);
3070}
3071
3074 D->setLocation(readSourceLocation());
3075 Expr *In = Record.readExpr();
3076 Expr *Out = Record.readExpr();
3077 D->setCombinerData(In, Out);
3078 Expr *Combiner = Record.readExpr();
3079 D->setCombiner(Combiner);
3080 Expr *Orig = Record.readExpr();
3081 Expr *Priv = Record.readExpr();
3082 D->setInitializerData(Orig, Priv);
3083 Expr *Init = Record.readExpr();
3084 auto IK = static_cast<OMPDeclareReductionInitKind>(Record.readInt());
3085 D->setInitializer(Init, IK);
3086 D->PrevDeclInScope = readDeclID().getRawValue();
3087}
3088
3090 Record.readOMPChildren(D->Data);
3092 D->VarName = Record.readDeclarationName();
3093 D->PrevDeclInScope = readDeclID().getRawValue();
3094}
3095
3097 VisitVarDecl(D);
3098}
3099
3100//===----------------------------------------------------------------------===//
3101// Attribute Reading
3102//===----------------------------------------------------------------------===//
3103
3104namespace {
3105class AttrReader {
3106 ASTRecordReader &Reader;
3107
3108public:
3109 AttrReader(ASTRecordReader &Reader) : Reader(Reader) {}
3110
3111 uint64_t readInt() {
3112 return Reader.readInt();
3113 }
3114
3115 bool readBool() { return Reader.readBool(); }
3116
3117 SourceRange readSourceRange() {
3118 return Reader.readSourceRange();
3119 }
3120
3121 SourceLocation readSourceLocation() {
3122 return Reader.readSourceLocation();
3123 }
3124
3125 Expr *readExpr() { return Reader.readExpr(); }
3126
3127 Attr *readAttr() { return Reader.readAttr(); }
3128
3129 std::string readString() {
3130 return Reader.readString();
3131 }
3132
3133 TypeSourceInfo *readTypeSourceInfo() {
3134 return Reader.readTypeSourceInfo();
3135 }
3136
3137 IdentifierInfo *readIdentifier() {
3138 return Reader.readIdentifier();
3139 }
3140
3141 VersionTuple readVersionTuple() {
3142 return Reader.readVersionTuple();
3143 }
3144
3145 OMPTraitInfo *readOMPTraitInfo() { return Reader.readOMPTraitInfo(); }
3146
3147 template <typename T> T *readDeclAs() { return Reader.readDeclAs<T>(); }
3148};
3149}
3150
3152 AttrReader Record(*this);
3153 auto V = Record.readInt();
3154 if (!V)
3155 return nullptr;
3156
3157 Attr *New = nullptr;
3158 // Kind is stored as a 1-based integer because 0 is used to indicate a null
3159 // Attr pointer.
3160 auto Kind = static_cast<attr::Kind>(V - 1);
3161 ASTContext &Context = getContext();
3162
3163 IdentifierInfo *AttrName = Record.readIdentifier();
3164 IdentifierInfo *ScopeName = Record.readIdentifier();
3165 SourceRange AttrRange = Record.readSourceRange();
3166 SourceLocation ScopeLoc = Record.readSourceLocation();
3167 unsigned ParsedKind = Record.readInt();
3168 unsigned Syntax = Record.readInt();
3169 unsigned SpellingIndex = Record.readInt();
3170 bool IsAlignas = (ParsedKind == AttributeCommonInfo::AT_Aligned &&
3172 SpellingIndex == AlignedAttr::Keyword_alignas);
3173 bool IsRegularKeywordAttribute = Record.readBool();
3174
3175 AttributeCommonInfo Info(AttrName, ScopeName, AttrRange, ScopeLoc,
3176 AttributeCommonInfo::Kind(ParsedKind),
3177 {AttributeCommonInfo::Syntax(Syntax), SpellingIndex,
3178 IsAlignas, IsRegularKeywordAttribute});
3179
3180#include "clang/Serialization/AttrPCHRead.inc"
3181
3182 assert(New && "Unable to decode attribute?");
3183 return New;
3184}
3185
3186/// Reads attributes from the current stream position.
3188 for (unsigned I = 0, E = readInt(); I != E; ++I)
3189 if (auto *A = readAttr())
3190 Attrs.push_back(A);
3191}
3192
3193//===----------------------------------------------------------------------===//
3194// ASTReader Implementation
3195//===----------------------------------------------------------------------===//
3196
3197/// Note that we have loaded the declaration with the given
3198/// Index.
3199///
3200/// This routine notes that this declaration has already been loaded,
3201/// so that future GetDecl calls will return this declaration rather
3202/// than trying to load a new declaration.
3203inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
3204 assert(!DeclsLoaded[Index] && "Decl loaded twice?");
3205 DeclsLoaded[Index] = D;
3206}
3207
3208/// Determine whether the consumer will be interested in seeing
3209/// this declaration (via HandleTopLevelDecl).
3210///
3211/// This routine should return true for anything that might affect
3212/// code generation, e.g., inline function definitions, Objective-C
3213/// declarations with metadata, etc.
3214bool ASTReader::isConsumerInterestedIn(Decl *D) {
3215 // An ObjCMethodDecl is never considered as "interesting" because its
3216 // implementation container always is.
3217
3218 // An ImportDecl or VarDecl imported from a module map module will get
3219 // emitted when we import the relevant module.
3221 auto *M = D->getImportedOwningModule();
3222 if (M && M->Kind == Module::ModuleMapModule &&
3223 getContext().DeclMustBeEmitted(D))
3224 return false;
3225 }
3226
3229 return true;
3232 return !D->getDeclContext()->isFunctionOrMethod();
3233 if (const auto *Var = dyn_cast<VarDecl>(D))
3234 return Var->isFileVarDecl() &&
3235 (Var->isThisDeclarationADefinition() == VarDecl::Definition ||
3236 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Var));
3237 if (const auto *Func = dyn_cast<FunctionDecl>(D))
3238 return Func->doesThisDeclarationHaveABody() || PendingBodies.count(D);
3239
3240 if (auto *ES = D->getASTContext().getExternalSource())
3241 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
3242 return true;
3243
3244 return false;
3245}
3246
3247/// Get the correct cursor and offset for loading a declaration.
3248ASTReader::RecordLocation ASTReader::DeclCursorForID(GlobalDeclID ID,
3251 assert(M);
3252 unsigned LocalDeclIndex = ID.getLocalDeclIndex();
3253 const DeclOffset &DOffs = M->DeclOffsets[LocalDeclIndex];
3254 Loc = ReadSourceLocation(*M, DOffs.getRawLoc());
3255 return RecordLocation(M, DOffs.getBitOffset(M->DeclsBlockStartOffset));
3256}
3257
3258ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
3259 auto I = GlobalBitOffsetsMap.find(GlobalOffset);
3260
3261 assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
3262 return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
3263}
3264
3265uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint64_t LocalOffset) {
3266 return LocalOffset + M.GlobalBitOffset;
3267}
3268
3270ASTDeclReader::getOrFakePrimaryClassDefinition(ASTReader &Reader,
3271 CXXRecordDecl *RD) {
3272 // Try to dig out the definition.
3273 auto *DD = RD->DefinitionData;
3274 if (!DD)
3275 DD = RD->getCanonicalDecl()->DefinitionData;
3276
3277 // If there's no definition yet, then DC's definition is added by an update
3278 // record, but we've not yet loaded that update record. In this case, we
3279 // commit to DC being the canonical definition now, and will fix this when
3280 // we load the update record.
3281 if (!DD) {
3282 DD = new (Reader.getContext()) struct CXXRecordDecl::DefinitionData(RD);
3283 RD->setCompleteDefinition(true);
3284 RD->DefinitionData = DD;
3285 RD->getCanonicalDecl()->DefinitionData = DD;
3286
3287 // Track that we did this horrible thing so that we can fix it later.
3288 Reader.PendingFakeDefinitionData.insert(
3289 std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));
3290 }
3291
3292 return DD->Definition;
3293}
3294
3295/// Find the context in which we should search for previous declarations when
3296/// looking for declarations to merge.
3297DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
3298 DeclContext *DC) {
3299 if (auto *ND = dyn_cast<NamespaceDecl>(DC))
3300 return ND->getFirstDecl();
3301
3302 if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
3303 return getOrFakePrimaryClassDefinition(Reader, RD);
3304
3305 if (auto *RD = dyn_cast<RecordDecl>(DC))
3306 return RD->getDefinition();
3307
3308 if (auto *ED = dyn_cast<EnumDecl>(DC))
3309 return ED->getDefinition();
3310
3311 if (auto *OID = dyn_cast<ObjCInterfaceDecl>(DC))
3312 return OID->getDefinition();
3313
3314 // We can see the TU here only if we have no Sema object. It is possible
3315 // we're in clang-repl so we still need to get the primary context.
3316 if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
3317 return TU->getPrimaryContext();
3318
3319 return nullptr;
3320}
3321
3322ASTDeclReader::FindExistingResult::~FindExistingResult() {
3323 // Record that we had a typedef name for linkage whether or not we merge
3324 // with that declaration.
3325 if (TypedefNameForLinkage) {
3326 DeclContext *DC = New->getDeclContext()->getRedeclContext();
3327 Reader.ImportedTypedefNamesForLinkage.insert(
3328 std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
3329 return;
3330 }
3331
3332 if (!AddResult || Existing)
3333 return;
3334
3335 DeclarationName Name = New->getDeclName();
3336 DeclContext *DC = New->getDeclContext()->getRedeclContext();
3338 setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
3339 AnonymousDeclNumber, New);
3340 } else if (DC->isTranslationUnit() &&
3341 !Reader.getContext().getLangOpts().CPlusPlus) {
3342 if (Reader.getIdResolver().tryAddTopLevelDecl(New, Name))
3343 Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
3344 .push_back(New);
3345 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3346 // Add the declaration to its redeclaration context so later merging
3347 // lookups will find it.
3348 MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
3349 }
3350}
3351
3352/// Find the declaration that should be merged into, given the declaration found
3353/// by name lookup. If we're merging an anonymous declaration within a typedef,
3354/// we need a matching typedef, and we merge with the type inside it.
3356 bool IsTypedefNameForLinkage) {
3357 if (!IsTypedefNameForLinkage)
3358 return Found;
3359
3360 // If we found a typedef declaration that gives a name to some other
3361 // declaration, then we want that inner declaration. Declarations from
3362 // AST files are handled via ImportedTypedefNamesForLinkage.
3363 if (Found->isFromASTFile())
3364 return nullptr;
3365
3366 if (auto *TND = dyn_cast<TypedefNameDecl>(Found))
3367 return TND->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
3368
3369 return nullptr;
3370}
3371
3372/// Find the declaration to use to populate the anonymous declaration table
3373/// for the given lexical DeclContext. We only care about finding local
3374/// definitions of the context; we'll merge imported ones as we go.
3376ASTDeclReader::getPrimaryDCForAnonymousDecl(DeclContext *LexicalDC) {
3377 // For classes, we track the definition as we merge.
3378 if (auto *RD = dyn_cast<CXXRecordDecl>(LexicalDC)) {
3379 auto *DD = RD->getCanonicalDecl()->DefinitionData;
3380 return DD ? DD->Definition : nullptr;
3381 } else if (auto *OID = dyn_cast<ObjCInterfaceDecl>(LexicalDC)) {
3382 return OID->getCanonicalDecl()->getDefinition();
3383 }
3384
3385 // For anything else, walk its merged redeclarations looking for a definition.
3386 // Note that we can't just call getDefinition here because the redeclaration
3387 // chain isn't wired up.
3388 for (auto *D : merged_redecls(cast<Decl>(LexicalDC))) {
3389 if (auto *FD = dyn_cast<FunctionDecl>(D))
3390 if (FD->isThisDeclarationADefinition())
3391 return FD;
3392 if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
3393 if (MD->isThisDeclarationADefinition())
3394 return MD;
3395 if (auto *RD = dyn_cast<RecordDecl>(D))
3397 return RD;
3398 }
3399
3400 // No merged definition yet.
3401 return nullptr;
3402}
3403
3404NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
3405 DeclContext *DC,
3406 unsigned Index) {
3407 // If the lexical context has been merged, look into the now-canonical
3408 // definition.
3409 auto *CanonDC = cast<Decl>(DC)->getCanonicalDecl();
3410
3411 // If we've seen this before, return the canonical declaration.
3412 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3413 if (Index < Previous.size() && Previous[Index])
3414 return Previous[Index];
3415
3416 // If this is the first time, but we have parsed a declaration of the context,
3417 // build the anonymous declaration list from the parsed declaration.
3418 auto *PrimaryDC = getPrimaryDCForAnonymousDecl(DC);
3419 if (PrimaryDC && !cast<Decl>(PrimaryDC)->isFromASTFile()) {
3420 numberAnonymousDeclsWithin(PrimaryDC, [&](NamedDecl *ND, unsigned Number) {
3421 if (Previous.size() == Number)
3422 Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
3423 else
3424 Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());
3425 });
3426 }
3427
3428 return Index < Previous.size() ? Previous[Index] : nullptr;
3429}
3430
3431void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
3432 DeclContext *DC, unsigned Index,
3433 NamedDecl *D) {
3434 auto *CanonDC = cast<Decl>(DC)->getCanonicalDecl();
3435
3436 auto &Previous = Reader.AnonymousDeclarationsForMerging[CanonDC];
3437 if (Index >= Previous.size())
3438 Previous.resize(Index + 1);
3439 if (!Previous[Index])
3440 Previous[Index] = D;
3441}
3442
3443ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
3444 DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
3445 : D->getDeclName();
3446
3447 if (!Name && !needsAnonymousDeclarationNumber(D)) {
3448 // Don't bother trying to find unnamed declarations that are in
3449 // unmergeable contexts.
3450 FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
3451 AnonymousDeclNumber, TypedefNameForLinkage);
3452 Result.suppress();
3453 return Result;
3454 }
3455
3456 ASTContext &C = Reader.getContext();
3458 if (TypedefNameForLinkage) {
3459 auto It = Reader.ImportedTypedefNamesForLinkage.find(
3460 std::make_pair(DC, TypedefNameForLinkage));
3461 if (It != Reader.ImportedTypedefNamesForLinkage.end())
3462 if (C.isSameEntity(It->second, D))
3463 return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
3464 TypedefNameForLinkage);
3465 // Go on to check in other places in case an existing typedef name
3466 // was not imported.
3467 }
3468
3470 // This is an anonymous declaration that we may need to merge. Look it up
3471 // in its context by number.
3472 if (auto *Existing = getAnonymousDeclForMerging(
3473 Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
3474 if (C.isSameEntity(Existing, D))
3475 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3476 TypedefNameForLinkage);
3477 } else if (DC->isTranslationUnit() &&
3478 !Reader.getContext().getLangOpts().CPlusPlus) {
3479 IdentifierResolver &IdResolver = Reader.getIdResolver();
3480
3481 // Temporarily consider the identifier to be up-to-date. We don't want to
3482 // cause additional lookups here.
3483 class UpToDateIdentifierRAII {
3484 IdentifierInfo *II;
3485 bool WasOutToDate = false;
3486
3487 public:
3488 explicit UpToDateIdentifierRAII(IdentifierInfo *II) : II(II) {
3489 if (II) {
3490 WasOutToDate = II->isOutOfDate();
3491 if (WasOutToDate)
3492 II->setOutOfDate(false);
3493 }
3494 }
3495
3496 ~UpToDateIdentifierRAII() {
3497 if (WasOutToDate)
3498 II->setOutOfDate(true);
3499 }
3500 } UpToDate(Name.getAsIdentifierInfo());
3501
3502 for (IdentifierResolver::iterator I = IdResolver.begin(Name),
3503 IEnd = IdResolver.end();
3504 I != IEnd; ++I) {
3505 if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
3506 if (C.isSameEntity(Existing, D))
3507 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3508 TypedefNameForLinkage);
3509 }
3510 } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
3511 DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
3512 for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
3513 if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
3514 if (C.isSameEntity(Existing, D))
3515 return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
3516 TypedefNameForLinkage);
3517 }
3518 } else {
3519 // Not in a mergeable context.
3520 return FindExistingResult(Reader);
3521 }
3522
3523 // If this declaration is from a merged context, make a note that we need to
3524 // check that the canonical definition of that context contains the decl.
3525 //
3526 // Note that we don't perform ODR checks for decls from the global module
3527 // fragment.
3528 //
3529 // FIXME: We should do something similar if we merge two definitions of the
3530 // same template specialization into the same CXXRecordDecl.
3531 auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
3532 if (MergedDCIt != Reader.MergedDeclContexts.end() &&
3533 !shouldSkipCheckingODR(D) && MergedDCIt->second == D->getDeclContext() &&
3534 !shouldSkipCheckingODR(cast<Decl>(D->getDeclContext())))
3535 Reader.PendingOdrMergeChecks.push_back(D);
3536
3537 return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3538 AnonymousDeclNumber, TypedefNameForLinkage);
3539}
3540
3541template<typename DeclT>
3543 return D->RedeclLink.getLatestNotUpdated();
3544}
3545
3547 llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3548}
3549
3551 assert(D);
3552
3553 switch (D->getKind()) {
3554#define ABSTRACT_DECL(TYPE)
3555#define DECL(TYPE, BASE) \
3556 case Decl::TYPE: \
3557 return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3558#include "clang/AST/DeclNodes.inc"
3559 }
3560 llvm_unreachable("unknown decl kind");
3561}
3562
3563Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3565}
3566
3567namespace {
3568void mergeInheritableAttributes(ASTReader &Reader, Decl *D, Decl *Previous) {
3569 InheritableAttr *NewAttr = nullptr;
3570 ASTContext &Context = Reader.getContext();
3571 const auto *IA = Previous->getAttr<MSInheritanceAttr>();
3572
3573 if (IA && !D->hasAttr<MSInheritanceAttr>()) {
3574 NewAttr = cast<InheritableAttr>(IA->clone(Context));
3575 NewAttr->setInherited(true);
3576 D->addAttr(NewAttr);
3577 }
3578
3579 const auto *AA = Previous->getAttr<AvailabilityAttr>();
3580 if (AA && !D->hasAttr<AvailabilityAttr>()) {
3581 NewAttr = AA->clone(Context);
3582 NewAttr->setInherited(true);
3583 D->addAttr(NewAttr);
3584 }
3585}
3586} // namespace
3587
3588template<typename DeclT>
3591 Decl *Previous, Decl *Canon) {
3592 D->RedeclLink.setPrevious(cast<DeclT>(Previous));
3593 D->First = cast<DeclT>(Previous)->First;
3594}
3595
3596namespace clang {
3597
3598template<>
3601 Decl *Previous, Decl *Canon) {
3602 auto *VD = static_cast<VarDecl *>(D);
3603 auto *PrevVD = cast<VarDecl>(Previous);
3604 D->RedeclLink.setPrevious(PrevVD);
3605 D->First = PrevVD->First;
3606
3607 // We should keep at most one definition on the chain.
3608 // FIXME: Cache the definition once we've found it. Building a chain with
3609 // N definitions currently takes O(N^2) time here.
3610 if (VD->isThisDeclarationADefinition() == VarDecl::Definition) {
3611 for (VarDecl *CurD = PrevVD; CurD; CurD = CurD->getPreviousDecl()) {
3612 if (CurD->isThisDeclarationADefinition() == VarDecl::Definition) {
3613 Reader.mergeDefinitionVisibility(CurD, VD);
3614 VD->demoteThisDefinitionToDeclaration();
3615 break;
3616 }
3617 }
3618 }
3619}
3620
3622 auto *DT = T->getContainedDeducedType();
3623 return DT && !DT->isDeduced();
3624}
3625
3626template<>
3629 Decl *Previous, Decl *Canon) {
3630 auto *FD = static_cast<FunctionDecl *>(D);
3631 auto *PrevFD = cast<FunctionDecl>(Previous);
3632
3633 FD->RedeclLink.setPrevious(PrevFD);
3634 FD->First = PrevFD->First;
3635
3636 // If the previous declaration is an inline function declaration, then this
3637 // declaration is too.
3638 if (PrevFD->isInlined() != FD->isInlined()) {
3639 // FIXME: [dcl.fct.spec]p4:
3640 // If a function with external linkage is declared inline in one
3641 // translation unit, it shall be declared inline in all translation
3642 // units in which it appears.
3643 //
3644 // Be careful of this case:
3645 //
3646 // module A:
3647 // template<typename T> struct X { void f(); };
3648 // template<typename T> inline void X<T>::f() {}
3649 //
3650 // module B instantiates the declaration of X<int>::f
3651 // module C instantiates the definition of X<int>::f
3652 //
3653 // If module B and C are merged, we do not have a violation of this rule.
3654 FD->setImplicitlyInline(true);
3655 }
3656
3657 auto *FPT = FD->getType()->getAs<FunctionProtoType>();
3658 auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
3659 if (FPT && PrevFPT) {
3660 // If we need to propagate an exception specification along the redecl
3661 // chain, make a note of that so that we can do so later.
3662 bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());
3663 bool WasUnresolved =
3665 if (IsUnresolved != WasUnresolved)
3666 Reader.PendingExceptionSpecUpdates.insert(
3667 {Canon, IsUnresolved ? PrevFD : FD});
3668
3669 // If we need to propagate a deduced return type along the redecl chain,
3670 // make a note of that so that we can do it later.
3671 bool IsUndeduced = isUndeducedReturnType(FPT->getReturnType());
3672 bool WasUndeduced = isUndeducedReturnType(PrevFPT->getReturnType());
3673 if (IsUndeduced != WasUndeduced)
3674 Reader.PendingDeducedTypeUpdates.insert(
3675 {cast<FunctionDecl>(Canon),
3676 (IsUndeduced ? PrevFPT : FPT)->getReturnType()});
3677 }
3678}
3679
3680} // namespace clang
3681
3683 llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3684}
3685
3686/// Inherit the default template argument from \p From to \p To. Returns
3687/// \c false if there is no default template for \p From.
3688template <typename ParmDecl>
3689static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,
3690 Decl *ToD) {
3691 auto *To = cast<ParmDecl>(ToD);
3692 if (!From->hasDefaultArgument())
3693 return false;
3694 To->setInheritedDefaultArgument(Context, From);
3695 return true;
3696}
3697
3699 TemplateDecl *From,
3700 TemplateDecl *To) {
3701 auto *FromTP = From->getTemplateParameters();
3702 auto *ToTP = To->getTemplateParameters();
3703 assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3704
3705 for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3706 NamedDecl *FromParam = FromTP->getParam(I);
3707 NamedDecl *ToParam = ToTP->getParam(I);
3708
3709 if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam))
3710 inheritDefaultTemplateArgument(Context, FTTP, ToParam);
3711 else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam))
3712 inheritDefaultTemplateArgument(Context, FNTTP, ToParam);
3713 else
3715 Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam);
3716 }
3717}
3718
3719// [basic.link]/p10:
3720// If two declarations of an entity are attached to different modules,
3721// the program is ill-formed;
3723 Decl *D,
3724 Decl *Previous) {
3725 // If it is previous implcitly introduced, it is not meaningful to
3726 // diagnose it.
3727 if (Previous->isImplicit())
3728 return;
3729
3730 // FIXME: Get rid of the enumeration of decl types once we have an appropriate
3731 // abstract for decls of an entity. e.g., the namespace decl and using decl
3732 // doesn't introduce an entity.
3733 if (!isa<VarDecl, FunctionDecl, TagDecl, RedeclarableTemplateDecl>(Previous))
3734 return;
3735
3736 // Skip implicit instantiations since it may give false positive diagnostic
3737 // messages.
3738 // FIXME: Maybe this shows the implicit instantiations may have incorrect
3739 // module owner ships. But given we've finished the compilation of a module,
3740 // how can we add new entities to that module?
3741 if (isa<VarTemplateSpecializationDecl>(Previous))
3742 return;
3743 if (isa<ClassTemplateSpecializationDecl>(Previous))
3744 return;
3745 if (auto *Func = dyn_cast<FunctionDecl>(Previous);
3746 Func && Func->getTemplateSpecializationInfo())
3747 return;
3748
3749 Module *M = Previous->getOwningModule();
3750 if (!M)
3751 return;
3752
3753 // We only forbids merging decls within named modules.
3754 if (!M->isNamedModule()) {
3755 // Try to warn the case that we merged decls from global module.
3756 if (!M->isGlobalModule())
3757 return;
3758
3759 if (D->getOwningModule() &&
3761 return;
3762
3763 Reader.PendingWarningForDuplicatedDefsInModuleUnits.push_back(
3764 {D, Previous});
3765 return;
3766 }
3767
3768 // It is fine if they are in the same module.
3769 if (Reader.getContext().isInSameModule(M, D->getOwningModule()))
3770 return;
3771
3772 Reader.Diag(Previous->getLocation(),
3773 diag::err_multiple_decl_in_different_modules)
3774 << cast<NamedDecl>(Previous) << M->Name;
3775 Reader.Diag(D->getLocation(), diag::note_also_found);
3776}
3777
3779 Decl *Previous, Decl *Canon) {
3780 assert(D && Previous);
3781
3782 switch (D->getKind()) {
3783#define ABSTRACT_DECL(TYPE)
3784#define DECL(TYPE, BASE) \
3785 case Decl::TYPE: \
3786 attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3787 break;
3788#include "clang/AST/DeclNodes.inc"
3789 }
3790
3792
3793 // If the declaration was visible in one module, a redeclaration of it in
3794 // another module remains visible even if it wouldn't be visible by itself.
3795 //
3796 // FIXME: In this case, the declaration should only be visible if a module
3797 // that makes it visible has been imported.
3799 Previous->IdentifierNamespace &
3801
3802 // If the declaration declares a template, it may inherit default arguments
3803 // from the previous declaration.
3804 if (auto *TD = dyn_cast<TemplateDecl>(D))
3806 cast<TemplateDecl>(Previous), TD);
3807
3808 // If any of the declaration in the chain contains an Inheritable attribute,
3809 // it needs to be added to all the declarations in the redeclarable chain.
3810 // FIXME: Only the logic of merging MSInheritableAttr is present, it should
3811 // be extended for all inheritable attributes.
3812 mergeInheritableAttributes(Reader, D, Previous);
3813}
3814
3815template<typename DeclT>
3817 D->RedeclLink.setLatest(cast<DeclT>(Latest));
3818}
3819
3821 llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3822}
3823
3825 assert(D && Latest);
3826
3827 switch (D->getKind()) {
3828#define ABSTRACT_DECL(TYPE)
3829#define DECL(TYPE, BASE) \
3830 case Decl::TYPE: \
3831 attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3832 break;
3833#include "clang/AST/DeclNodes.inc"
3834 }
3835}
3836
3837template<typename DeclT>
3839 D->RedeclLink.markIncomplete();
3840}
3841
3843 llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
3844}
3845
3846void ASTReader::markIncompleteDeclChain(Decl *D) {
3847 switch (D->getKind()) {
3848#define ABSTRACT_DECL(TYPE)
3849#define DECL(TYPE, BASE) \
3850 case Decl::TYPE: \
3851 ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3852 break;
3853#include "clang/AST/DeclNodes.inc"
3854 }
3855}
3856
3857/// Read the declaration at the given offset from the AST file.
3858Decl *ASTReader::ReadDeclRecord(GlobalDeclID ID) {
3859 SourceLocation DeclLoc;
3860 RecordLocation Loc = DeclCursorForID(ID, DeclLoc);
3861 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3862 // Keep track of where we are in the stream, then jump back there
3863 // after reading this declaration.
3864 SavedStreamPosition SavedPosition(DeclsCursor);
3865
3866 ReadingKindTracker ReadingKind(Read_Decl, *this);
3867
3868 // Note that we are loading a declaration record.
3869 Deserializing ADecl(this);
3870
3871 auto Fail = [](const char *what, llvm::Error &&Err) {
3872 llvm::report_fatal_error(Twine("ASTReader::readDeclRecord failed ") + what +
3873 ": " + toString(std::move(Err)));
3874 };
3875
3876 if (llvm::Error JumpFailed = DeclsCursor.JumpToBit(Loc.Offset))
3877 Fail("jumping", std::move(JumpFailed));
3878 ASTRecordReader Record(*this, *Loc.F);
3879 ASTDeclReader Reader(*this, Record, Loc, ID, DeclLoc);
3880 Expected<unsigned> MaybeCode = DeclsCursor.ReadCode();
3881 if (!MaybeCode)
3882 Fail("reading code", MaybeCode.takeError());
3883 unsigned Code = MaybeCode.get();
3884
3885 ASTContext &Context = getContext();
3886 Decl *D = nullptr;
3887 Expected<unsigned> MaybeDeclCode = Record.readRecord(DeclsCursor, Code);
3888 if (!MaybeDeclCode)
3889 llvm::report_fatal_error(
3890 Twine("ASTReader::readDeclRecord failed reading decl code: ") +
3891 toString(MaybeDeclCode.takeError()));
3892
3893 switch ((DeclCode)MaybeDeclCode.get()) {
3900 llvm_unreachable("Record cannot be de-serialized with readDeclRecord");
3901 case DECL_TYPEDEF:
3902 D = TypedefDecl::CreateDeserialized(Context, ID);
3903 break;
3904 case DECL_TYPEALIAS:
3905 D = TypeAliasDecl::CreateDeserialized(Context, ID);
3906 break;
3907 case DECL_ENUM:
3908 D = EnumDecl::CreateDeserialized(Context, ID);
3909 break;
3910 case DECL_RECORD:
3911 D = RecordDecl::CreateDeserialized(Context, ID);
3912 break;
3913 case DECL_ENUM_CONSTANT:
3915 break;
3916 case DECL_FUNCTION:
3917 D = FunctionDecl::CreateDeserialized(Context, ID);
3918 break;
3919 case DECL_LINKAGE_SPEC:
3921 break;
3922 case DECL_EXPORT:
3923 D = ExportDecl::CreateDeserialized(Context, ID);
3924 break;
3925 case DECL_LABEL:
3926 D = LabelDecl::CreateDeserialized(Context, ID);
3927 break;
3928 case DECL_NAMESPACE:
3929 D = NamespaceDecl::CreateDeserialized(Context, ID);
3930 break;
3933 break;
3934 case DECL_USING:
3935 D = UsingDecl::CreateDeserialized(Context, ID);
3936 break;
3937 case DECL_USING_PACK:
3938 D = UsingPackDecl::CreateDeserialized(Context, ID, Record.readInt());
3939 break;
3940 case DECL_USING_SHADOW:
3942 break;
3943 case DECL_USING_ENUM:
3944 D = UsingEnumDecl::CreateDeserialized(Context, ID);
3945 break;
3948 break;
3951 break;
3954 break;
3957 break;
3960 break;
3961 case DECL_CXX_RECORD:
3962 D = CXXRecordDecl::CreateDeserialized(Context, ID);
3963 break;
3966 break;
3967 case DECL_CXX_METHOD:
3968 D = CXXMethodDecl::CreateDeserialized(Context, ID);
3969 break;
3971 D = CXXConstructorDecl::CreateDeserialized(Context, ID, Record.readInt());
3972 break;
3975 break;
3978 break;
3979 case DECL_ACCESS_SPEC:
3981 break;
3982 case DECL_FRIEND:
3983 D = FriendDecl::CreateDeserialized(Context, ID, Record.readInt());
3984 break;
3987 break;
3990 break;
3993 break;
3996 break;
3997 case DECL_VAR_TEMPLATE:
3999 break;
4002 break;
4005 break;
4008 break;
4010 bool HasTypeConstraint = Record.readInt();
4012 HasTypeConstraint);
4013 break;
4014 }
4016 bool HasTypeConstraint = Record.readInt();
4018 HasTypeConstraint);
4019 break;
4020 }
4022 bool HasTypeConstraint = Record.readInt();
4024 Context, ID, Record.readInt(), HasTypeConstraint);
4025 break;
4026 }
4029 break;
4032 Record.readInt());
4033 break;
4036 break;
4037 case DECL_CONCEPT:
4038 D = ConceptDecl::CreateDeserialized(Context, ID);
4039 break;
4042 break;
4043 case DECL_STATIC_ASSERT:
4045 break;
4046 case DECL_OBJC_METHOD:
4048 break;
4051 break;
4052 case DECL_OBJC_IVAR:
4053 D = ObjCIvarDecl::CreateDeserialized(Context, ID);
4054 break;
4055 case DECL_OBJC_PROTOCOL:
4057 break;
4060 break;
4061 case DECL_OBJC_CATEGORY:
4063 break;
4066 break;
4069 break;
4072 break;
4073 case DECL_OBJC_PROPERTY:
4075 break;
4078 break;
4079 case DECL_FIELD:
4080 D = FieldDecl::CreateDeserialized(Context, ID);
4081 break;
4082 case DECL_INDIRECTFIELD:
4084 break;
4085 case DECL_VAR:
4086 D = VarDecl::CreateDeserialized(Context, ID);
4087 break;
4090 break;
4091 case DECL_PARM_VAR:
4092 D = ParmVarDecl::CreateDeserialized(Context, ID);
4093 break;
4094 case DECL_DECOMPOSITION:
4095 D = DecompositionDecl::CreateDeserialized(Context, ID, Record.readInt());
4096 break;
4097 case DECL_BINDING:
4098 D = BindingDecl::CreateDeserialized(Context, ID);
4099 break;
4102 break;
4105 break;
4106 case DECL_BLOCK:
4107 D = BlockDecl::CreateDeserialized(Context, ID);
4108 break;
4109 case DECL_MS_PROPERTY:
4111 break;
4112 case DECL_MS_GUID:
4113 D = MSGuidDecl::CreateDeserialized(Context, ID);
4114 break;
4116 D = UnnamedGlobalConstantDecl::CreateDeserialized(Context, ID);
4117 break;
4119 D = TemplateParamObjectDecl::CreateDeserialized(Context, ID);
4120 break;
4122 D = OutlinedFunctionDecl::CreateDeserialized(Context, ID, Record.readInt());
4123 break;
4124 case DECL_CAPTURED:
4125 D = CapturedDecl::CreateDeserialized(Context, ID, Record.readInt());
4126 break;
4128 Error("attempt to read a C++ base-specifier record as a declaration");
4129 return nullptr;
4131 Error("attempt to read a C++ ctor initializer record as a declaration");
4132 return nullptr;
4133 case DECL_IMPORT:
4134 // Note: last entry of the ImportDecl record is the number of stored source
4135 // locations.
4136 D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
4137 break;
4139 Record.skipInts(1);
4140 unsigned NumChildren = Record.readInt();
4141 Record.skipInts(1);
4142 D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, NumChildren);
4143 break;
4144 }
4145 case DECL_OMP_ALLOCATE: {
4146 unsigned NumClauses = Record.readInt();
4147 unsigned NumVars = Record.readInt();
4148 Record.skipInts(1);
4149 D = OMPAllocateDecl::CreateDeserialized(Context, ID, NumVars, NumClauses);
4150 break;
4151 }
4152 case DECL_OMP_REQUIRES: {
4153 unsigned NumClauses = Record.readInt();
4154 Record.skipInts(2);
4155 D = OMPRequiresDecl::CreateDeserialized(Context, ID, NumClauses);
4156 break;
4157 }
4160 break;
4162 unsigned NumClauses = Record.readInt();
4163 Record.skipInts(2);
4164 D = OMPDeclareMapperDecl::CreateDeserialized(Context, ID, NumClauses);
4165 break;
4166 }
4169 break;
4171 D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record.readInt());
4172 break;
4175 Record.readInt());
4176 break;
4177 case DECL_EMPTY:
4178 D = EmptyDecl::CreateDeserialized(Context, ID);
4179 break;
4182 break;
4185 break;
4186 case DECL_HLSL_BUFFER:
4188 break;
4191 Record.readInt());
4192 break;
4193 }
4194
4195 assert(D && "Unknown declaration reading AST file");
4196 LoadedDecl(translateGlobalDeclIDToIndex(ID), D);
4197 // Set the DeclContext before doing any deserialization, to make sure internal
4198 // calls to Decl::getASTContext() by Decl's methods will find the
4199 // TranslationUnitDecl without crashing.
4201
4202 // Reading some declarations can result in deep recursion.
4203 runWithSufficientStackSpace(DeclLoc, [&] { Reader.Visit(D); });
4204
4205 // If this declaration is also a declaration context, get the
4206 // offsets for its tables of lexical and visible declarations.
4207 if (auto *DC = dyn_cast<DeclContext>(D)) {
4208 uint64_t LexicalOffset = 0;
4209 uint64_t VisibleOffset = 0;
4210 uint64_t ModuleLocalOffset = 0;
4211 uint64_t TULocalOffset = 0;
4212
4213 Reader.VisitDeclContext(DC, LexicalOffset, VisibleOffset, ModuleLocalOffset,
4214 TULocalOffset);
4215
4216 // Get the lexical and visible block for the delayed namespace.
4217 // It is sufficient to judge if ID is in DelayedNamespaceOffsetMap.
4218 // But it may be more efficient to filter the other cases.
4219 if (!LexicalOffset && !VisibleOffset && !ModuleLocalOffset &&
4220 isa<NamespaceDecl>(D))
4221 if (auto Iter = DelayedNamespaceOffsetMap.find(ID);
4222 Iter != DelayedNamespaceOffsetMap.end()) {
4223 LexicalOffset = Iter->second.LexicalOffset;
4224 VisibleOffset = Iter->second.VisibleOffset;
4225 ModuleLocalOffset = Iter->second.ModuleLocalOffset;
4226 TULocalOffset = Iter->second.TULocalOffset;
4227 }
4228
4229 if (LexicalOffset &&
4230 ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, LexicalOffset, DC))
4231 return nullptr;
4232 if (VisibleOffset && ReadVisibleDeclContextStorage(
4233 *Loc.F, DeclsCursor, VisibleOffset, ID,
4234 VisibleDeclContextStorageKind::GenerallyVisible))
4235 return nullptr;
4236 if (ModuleLocalOffset &&
4237 ReadVisibleDeclContextStorage(
4238 *Loc.F, DeclsCursor, ModuleLocalOffset, ID,
4239 VisibleDeclContextStorageKind::ModuleLocalVisible))
4240 return nullptr;
4241 if (TULocalOffset && ReadVisibleDeclContextStorage(
4242 *Loc.F, DeclsCursor, TULocalOffset, ID,
4243 VisibleDeclContextStorageKind::TULocalVisible))
4244 return nullptr;
4245 }
4246 assert(Record.getIdx() == Record.size());
4247
4248 // Load any relevant update records.
4249 PendingUpdateRecords.push_back(
4250 PendingUpdateRecord(ID, D, /*JustLoaded=*/true));
4251
4252 // Load the categories after recursive loading is finished.
4253 if (auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
4254 // If we already have a definition when deserializing the ObjCInterfaceDecl,
4255 // we put the Decl in PendingDefinitions so we can pull the categories here.
4256 if (Class->isThisDeclarationADefinition() ||
4257 PendingDefinitions.count(Class))
4258 loadObjCCategories(ID, Class);
4259
4260 // If we have deserialized a declaration that has a definition the
4261 // AST consumer might need to know about, queue it.
4262 // We don't pass it to the consumer immediately because we may be in recursive
4263 // loading, and some declarations may still be initializing.
4264 PotentiallyInterestingDecls.push_back(D);
4265
4266 return D;
4267}
4268
4269void ASTReader::PassInterestingDeclsToConsumer() {
4270 assert(Consumer);
4271
4272 if (PassingDeclsToConsumer)
4273 return;
4274
4275 // Guard variable to avoid recursively redoing the process of passing
4276 // decls to consumer.
4277 SaveAndRestore GuardPassingDeclsToConsumer(PassingDeclsToConsumer, true);
4278
4279 // Ensure that we've loaded all potentially-interesting declarations
4280 // that need to be eagerly loaded.
4281 for (auto ID : EagerlyDeserializedDecls)
4282 GetDecl(ID);
4283 EagerlyDeserializedDecls.clear();
4284
4285 auto ConsumingPotentialInterestingDecls = [this]() {
4286 while (!PotentiallyInterestingDecls.empty()) {
4287 Decl *D = PotentiallyInterestingDecls.front();
4288 PotentiallyInterestingDecls.pop_front();
4289 if (isConsumerInterestedIn(D))
4290 PassInterestingDeclToConsumer(D);
4291 }
4292 };
4293 std::deque<Decl *> MaybeInterestingDecls =
4294 std::move(PotentiallyInterestingDecls);
4295 PotentiallyInterestingDecls.clear();
4296 assert(PotentiallyInterestingDecls.empty());
4297 while (!MaybeInterestingDecls.empty()) {
4298 Decl *D = MaybeInterestingDecls.front();
4299 MaybeInterestingDecls.pop_front();
4300 // Since we load the variable's initializers lazily, it'd be problematic
4301 // if the initializers dependent on each other. So here we try to load the
4302 // initializers of static variables to make sure they are passed to code
4303 // generator by order. If we read anything interesting, we would consume
4304 // that before emitting the current declaration.
4305 if (auto *VD = dyn_cast<VarDecl>(D);
4306 VD && VD->isFileVarDecl() && !VD->isExternallyVisible())
4307 VD->getInit();
4308 ConsumingPotentialInterestingDecls();
4309 if (isConsumerInterestedIn(D))
4310 PassInterestingDeclToConsumer(D);
4311 }
4312
4313 // If we add any new potential interesting decl in the last call, consume it.
4314 ConsumingPotentialInterestingDecls();
4315
4316 for (GlobalDeclID ID : VTablesToEmit) {
4317 auto *RD = cast<CXXRecordDecl>(GetDecl(ID));
4318 assert(!RD->shouldEmitInExternalSource());
4319 PassVTableToConsumer(RD);
4320 }
4321 VTablesToEmit.clear();
4322}
4323
4324void ASTReader::loadDeclUpdateRecords(PendingUpdateRecord &Record) {
4325 // The declaration may have been modified by files later in the chain.
4326 // If this is the case, read the record containing the updates from each file
4327 // and pass it to ASTDeclReader to make the modifications.
4328 GlobalDeclID ID = Record.ID;
4329 Decl *D = Record.D;
4330 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
4331 DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
4332
4333 if (UpdI != DeclUpdateOffsets.end()) {
4334 auto UpdateOffsets = std::move(UpdI->second);
4335 DeclUpdateOffsets.erase(UpdI);
4336
4337 // Check if this decl was interesting to the consumer. If we just loaded
4338 // the declaration, then we know it was interesting and we skip the call
4339 // to isConsumerInterestedIn because it is unsafe to call in the
4340 // current ASTReader state.
4341 bool WasInteresting = Record.JustLoaded || isConsumerInterestedIn(D);
4342 for (auto &FileAndOffset : UpdateOffsets) {
4343 ModuleFile *F = FileAndOffset.first;
4344 uint64_t Offset = FileAndOffset.second;
4345 llvm::BitstreamCursor &Cursor = F->DeclsCursor;
4346 SavedStreamPosition SavedPosition(Cursor);
4347 if (llvm::Error JumpFailed = Cursor.JumpToBit(Offset))
4348 // FIXME don't do a fatal error.
4349 llvm::report_fatal_error(
4350 Twine("ASTReader::loadDeclUpdateRecords failed jumping: ") +
4351 toString(std::move(JumpFailed)));
4352 Expected<unsigned> MaybeCode = Cursor.ReadCode();
4353 if (!MaybeCode)
4354 llvm::report_fatal_error(
4355 Twine("ASTReader::loadDeclUpdateRecords failed reading code: ") +
4356 toString(MaybeCode.takeError()));
4357 unsigned Code = MaybeCode.get();
4358 ASTRecordReader Record(*this, *F);
4359 if (Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code))
4360 assert(MaybeRecCode.get() == DECL_UPDATES &&
4361 "Expected DECL_UPDATES record!");
4362 else
4363 llvm::report_fatal_error(
4364 Twine("ASTReader::loadDeclUpdateRecords failed reading rec code: ") +
4365 toString(MaybeCode.takeError()));
4366
4367 ASTDeclReader Reader(*this, Record, RecordLocation(F, Offset), ID,
4368 SourceLocation());
4369 Reader.UpdateDecl(D);
4370
4371 // We might have made this declaration interesting. If so, remember that
4372 // we need to hand it off to the consumer.
4373 if (!WasInteresting && isConsumerInterestedIn(D)) {
4374 PotentiallyInterestingDecls.push_back(D);
4375 WasInteresting = true;
4376 }
4377 }
4378 }
4379
4380 // Load the pending visible updates for this decl context, if it has any.
4381 if (auto I = PendingVisibleUpdates.find(ID);
4382 I != PendingVisibleUpdates.end()) {
4383 auto VisibleUpdates = std::move(I->second);
4384 PendingVisibleUpdates.erase(I);
4385
4386 auto *DC = cast<DeclContext>(D)->getPrimaryContext();
4387 for (const auto &Update : VisibleUpdates)
4388 Lookups[DC].Table.add(
4389 Update.Mod, Update.Data,
4392 }
4393
4394 if (auto I = PendingModuleLocalVisibleUpdates.find(ID);
4395 I != PendingModuleLocalVisibleUpdates.end()) {
4396 auto ModuleLocalVisibleUpdates = std::move(I->second);
4397 PendingModuleLocalVisibleUpdates.erase(I);
4398
4399 auto *DC = cast<DeclContext>(D)->getPrimaryContext();
4400 for (const auto &Update : ModuleLocalVisibleUpdates)
4401 ModuleLocalLookups[DC].Table.add(
4402 Update.Mod, Update.Data,
4404 // NOTE: Can we optimize the case that the data being loaded
4405 // is not related to current module?
4407 }
4408
4409 if (auto I = TULocalUpdates.find(ID); I != TULocalUpdates.end()) {
4410 auto Updates = std::move(I->second);
4411 TULocalUpdates.erase(I);
4412
4413 auto *DC = cast<DeclContext>(D)->getPrimaryContext();
4414 for (const auto &Update : Updates)
4415 TULocalLookups[DC].Table.add(
4416 Update.Mod, Update.Data,
4419 }
4420
4421 // Load any pending related decls.
4422 if (D->isCanonicalDecl()) {
4423 if (auto IT = RelatedDeclsMap.find(ID); IT != RelatedDeclsMap.end()) {
4424 for (auto LID : IT->second)
4425 GetDecl(LID);
4426 RelatedDeclsMap.erase(IT);
4427 }
4428 }
4429
4430 // Load the pending specializations update for this decl, if it has any.
4431 if (auto I = PendingSpecializationsUpdates.find(ID);
4432 I != PendingSpecializationsUpdates.end()) {
4433 auto SpecializationUpdates = std::move(I->second);
4434 PendingSpecializationsUpdates.erase(I);
4435
4436 for (const auto &Update : SpecializationUpdates)
4437 AddSpecializations(D, Update.Data, *Update.Mod, /*IsPartial=*/false);
4438 }
4439
4440 // Load the pending specializations update for this decl, if it has any.
4441 if (auto I = PendingPartialSpecializationsUpdates.find(ID);
4442 I != PendingPartialSpecializationsUpdates.end()) {
4443 auto SpecializationUpdates = std::move(I->second);
4444 PendingPartialSpecializationsUpdates.erase(I);
4445
4446 for (const auto &Update : SpecializationUpdates)
4447 AddSpecializations(D, Update.Data, *Update.Mod, /*IsPartial=*/true);
4448 }
4449}
4450
4451void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
4452 // Attach FirstLocal to the end of the decl chain.
4453 Decl *CanonDecl = FirstLocal->getCanonicalDecl();
4454 if (FirstLocal != CanonDecl) {
4455 Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);
4457 *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
4458 CanonDecl);
4459 }
4460
4461 if (!LocalOffset) {
4462 ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);
4463 return;
4464 }
4465
4466 // Load the list of other redeclarations from this module file.
4467 ModuleFile *M = getOwningModuleFile(FirstLocal);
4468 assert(M && "imported decl from no module file");
4469
4470 llvm::BitstreamCursor &Cursor = M->DeclsCursor;
4471 SavedStreamPosition SavedPosition(Cursor);
4472 if (llvm::Error JumpFailed = Cursor.JumpToBit(LocalOffset))
4473 llvm::report_fatal_error(
4474 Twine("ASTReader::loadPendingDeclChain failed jumping: ") +
4475 toString(std::move(JumpFailed)));
4476
4478 Expected<unsigned> MaybeCode = Cursor.ReadCode();
4479 if (!MaybeCode)
4480 llvm::report_fatal_error(
4481 Twine("ASTReader::loadPendingDeclChain failed reading code: ") +
4482 toString(MaybeCode.takeError()));
4483 unsigned Code = MaybeCode.get();
4484 if (Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record))
4485 assert(MaybeRecCode.get() == LOCAL_REDECLARATIONS &&
4486 "expected LOCAL_REDECLARATIONS record!");
4487 else
4488 llvm::report_fatal_error(
4489 Twine("ASTReader::loadPendingDeclChain failed reading rec code: ") +
4490 toString(MaybeCode.takeError()));
4491
4492 // FIXME: We have several different dispatches on decl kind here; maybe
4493 // we should instead generate one loop per kind and dispatch up-front?
4494 Decl *MostRecent = FirstLocal;
4495 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
4496 unsigned Idx = N - I - 1;
4497 auto *D = ReadDecl(*M, Record, Idx);
4498 ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
4499 MostRecent = D;
4500 }
4501 ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
4502}
4503
4504namespace {
4505
4506 /// Given an ObjC interface, goes through the modules and links to the
4507 /// interface all the categories for it.
4508 class ObjCCategoriesVisitor {
4509 ASTReader &Reader;
4511 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
4512 ObjCCategoryDecl *Tail = nullptr;
4513 llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
4514 GlobalDeclID InterfaceID;
4515 unsigned PreviousGeneration;
4516
4517 void add(ObjCCategoryDecl *Cat) {
4518 // Only process each category once.
4519 if (!Deserialized.erase(Cat))
4520 return;
4521
4522 // Check for duplicate categories.
4523 if (Cat->getDeclName()) {
4524 ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
4525 if (Existing && Reader.getOwningModuleFile(Existing) !=
4526 Reader.getOwningModuleFile(Cat)) {
4529 Cat->getASTContext(), Existing->getASTContext(),
4530 NonEquivalentDecls, StructuralEquivalenceKind::Default,
4531 /*StrictTypeSpelling =*/false,
4532 /*Complain =*/false,
4533 /*ErrorOnTagTypeMismatch =*/true);
4534 if (!Ctx.IsEquivalent(Cat, Existing)) {
4535 // Warn only if the categories with the same name are different.
4536 Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
4537 << Interface->getDeclName() << Cat->getDeclName();
4538 Reader.Diag(Existing->getLocation(),
4539 diag::note_previous_definition);
4540 }
4541 } else if (!Existing) {
4542 // Record this category.
4543 Existing = Cat;
4544 }
4545 }
4546
4547 // Add this category to the end of the chain.
4548 if (Tail)
4550 else
4551 Interface->setCategoryListRaw(Cat);
4552 Tail = Cat;
4553 }
4554
4555 public:
4556 ObjCCategoriesVisitor(
4558 llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
4559 GlobalDeclID InterfaceID, unsigned PreviousGeneration)
4560 : Reader(Reader), Interface(Interface), Deserialized(Deserialized),
4561 InterfaceID(InterfaceID), PreviousGeneration(PreviousGeneration) {
4562 // Populate the name -> category map with the set of known categories.
4563 for (auto *Cat : Interface->known_categories()) {
4564 if (Cat->getDeclName())
4565 NameCategoryMap[Cat->getDeclName()] = Cat;
4566
4567 // Keep track of the tail of the category list.
4568 Tail = Cat;
4569 }
4570 }
4571
4572 bool operator()(ModuleFile &M) {
4573 // If we've loaded all of the category information we care about from
4574 // this module file, we're done.
4575 if (M.Generation <= PreviousGeneration)
4576 return true;
4577
4578 // Map global ID of the definition down to the local ID used in this
4579 // module file. If there is no such mapping, we'll find nothing here
4580 // (or in any module it imports).
4581 LocalDeclID LocalID =
4582 Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
4583 if (LocalID.isInvalid())
4584 return true;
4585
4586 // Perform a binary search to find the local redeclarations for this
4587 // declaration (if any).
4588 const ObjCCategoriesInfo Compare = { LocalID, 0 };
4589 const ObjCCategoriesInfo *Result
4590 = std::lower_bound(M.ObjCCategoriesMap,
4592 Compare);
4593 if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
4594 LocalID != Result->getDefinitionID()) {
4595 // We didn't find anything. If the class definition is in this module
4596 // file, then the module files it depends on cannot have any categories,
4597 // so suppress further lookup.
4598 return Reader.isDeclIDFromModule(InterfaceID, M);
4599 }
4600
4601 // We found something. Dig out all of the categories.
4602 unsigned Offset = Result->Offset;
4603 unsigned N = M.ObjCCategories[Offset];
4604 M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
4605 for (unsigned I = 0; I != N; ++I)
4606 add(Reader.ReadDeclAs<ObjCCategoryDecl>(M, M.ObjCCategories, Offset));
4607 return true;
4608 }
4609 };
4610
4611} // namespace
4612
4613void ASTReader::loadObjCCategories(GlobalDeclID ID, ObjCInterfaceDecl *D,
4614 unsigned PreviousGeneration) {
4615 ObjCCategoriesVisitor Visitor(*this, D, CategoriesDeserialized, ID,
4616 PreviousGeneration);
4617 ModuleMgr.visit(Visitor);
4618}
4619
4620template<typename DeclT, typename Fn>
4621static void forAllLaterRedecls(DeclT *D, Fn F) {
4622 F(D);
4623
4624 // Check whether we've already merged D into its redeclaration chain.
4625 // MostRecent may or may not be nullptr if D has not been merged. If
4626 // not, walk the merged redecl chain and see if it's there.
4627 auto *MostRecent = D->getMostRecentDecl();
4628 bool Found = false;
4629 for (auto *Redecl = MostRecent; Redecl && !Found;
4630 Redecl = Redecl->getPreviousDecl())
4631 Found = (Redecl == D);
4632
4633 // If this declaration is merged, apply the functor to all later decls.
4634 if (Found) {
4635 for (auto *Redecl = MostRecent; Redecl != D;
4636 Redecl = Redecl->getPreviousDecl())
4637 F(Redecl);
4638 }
4639}
4640
4642 while (Record.getIdx() < Record.size()) {
4643 switch ((DeclUpdateKind)Record.readInt()) {
4645 auto *RD = cast<CXXRecordDecl>(D);
4646 Decl *MD = Record.readDecl();
4647 assert(MD && "couldn't read decl from update record");
4648 Reader.PendingAddedClassMembers.push_back({RD, MD});
4649 break;
4650 }
4651
4653 auto *Anon = readDeclAs<NamespaceDecl>();
4654
4655 // Each module has its own anonymous namespace, which is disjoint from
4656 // any other module's anonymous namespaces, so don't attach the anonymous
4657 // namespace at all.
4658 if (!Record.isModule()) {
4659 if (auto *TU = dyn_cast<TranslationUnitDecl>(D))
4660 TU->setAnonymousNamespace(Anon);
4661 else
4662 cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
4663 }
4664 break;
4665 }
4666
4668 auto *VD = cast<VarDecl>(D);
4669 VD->NonParmVarDeclBits.IsInline = Record.readInt();
4670 VD->NonParmVarDeclBits.IsInlineSpecified = Record.readInt();
4671 ReadVarDeclInit(VD);
4672 break;
4673 }
4674
4676 SourceLocation POI = Record.readSourceLocation();
4677 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D)) {
4678 VTSD->setPointOfInstantiation(POI);
4679 } else if (auto *VD = dyn_cast<VarDecl>(D)) {
4680 MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo();
4681 assert(MSInfo && "No member specialization information");
4682 MSInfo->setPointOfInstantiation(POI);
4683 } else {
4684 auto *FD = cast<FunctionDecl>(D);
4685 if (auto *FTSInfo = FD->TemplateOrSpecialization
4687 FTSInfo->setPointOfInstantiation(POI);
4688 else
4689 cast<MemberSpecializationInfo *>(FD->TemplateOrSpecialization)
4690 ->setPointOfInstantiation(POI);
4691 }
4692 break;
4693 }
4694
4696 auto *Param = cast<ParmVarDecl>(D);
4697
4698 // We have to read the default argument regardless of whether we use it
4699 // so that hypothetical further update records aren't messed up.
4700 // TODO: Add a function to skip over the next expr record.
4701 auto *DefaultArg = Record.readExpr();
4702
4703 // Only apply the update if the parameter still has an uninstantiated
4704 // default argument.
4705 if (Param->hasUninstantiatedDefaultArg())
4706 Param->setDefaultArg(DefaultArg);
4707 break;
4708 }
4709
4711 auto *FD = cast<FieldDecl>(D);
4712 auto *DefaultInit = Record.readExpr();
4713
4714 // Only apply the update if the field still has an uninstantiated
4715 // default member initializer.
4716 if (FD->hasInClassInitializer() && !FD->hasNonNullInClassInitializer()) {
4717 if (DefaultInit)
4718 FD->setInClassInitializer(DefaultInit);
4719 else
4720 // Instantiation failed. We can get here if we serialized an AST for
4721 // an invalid program.
4722 FD->removeInClassInitializer();
4723 }
4724 break;
4725 }
4726
4728 auto *FD = cast<FunctionDecl>(D);
4729 if (Reader.PendingBodies[FD]) {
4730 // FIXME: Maybe check for ODR violations.
4731 // It's safe to stop now because this update record is always last.
4732 return;
4733 }
4734
4735 if (Record.readInt()) {
4736 // Maintain AST consistency: any later redeclarations of this function
4737 // are inline if this one is. (We might have merged another declaration
4738 // into this one.)
4739 forAllLaterRedecls(FD, [](FunctionDecl *FD) {
4740 FD->setImplicitlyInline();
4741 });
4742 }
4743 FD->setInnerLocStart(readSourceLocation());
4745 assert(Record.getIdx() == Record.size() && "lazy body must be last");
4746 break;
4747 }
4748
4750 auto *RD = cast<CXXRecordDecl>(D);
4751 auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
4752 bool HadRealDefinition =
4753 OldDD && (OldDD->Definition != RD ||
4754 !Reader.PendingFakeDefinitionData.count(OldDD));
4755 RD->setParamDestroyedInCallee(Record.readInt());
4757 static_cast<RecordArgPassingKind>(Record.readInt()));
4758 ReadCXXRecordDefinition(RD, /*Update*/true);
4759
4760 // Visible update is handled separately.
4761 uint64_t LexicalOffset = ReadLocalOffset();
4762 if (!HadRealDefinition && LexicalOffset) {
4763 Record.readLexicalDeclContextStorage(LexicalOffset, RD);
4764 Reader.PendingFakeDefinitionData.erase(OldDD);
4765 }
4766
4767 auto TSK = (TemplateSpecializationKind)Record.readInt();
4768 SourceLocation POI = readSourceLocation();
4769 if (MemberSpecializationInfo *MSInfo =
4771 MSInfo->setTemplateSpecializationKind(TSK);
4772 MSInfo->setPointOfInstantiation(POI);
4773 } else {
4774 auto *Spec = cast<ClassTemplateSpecializationDecl>(RD);
4775 Spec->setTemplateSpecializationKind(TSK);
4776 Spec->setPointOfInstantiation(POI);
4777
4778 if (Record.readInt()) {
4779 auto *PartialSpec =
4780 readDeclAs<ClassTemplatePartialSpecializationDecl>();
4782 Record.readTemplateArgumentList(TemplArgs);
4783 auto *TemplArgList = TemplateArgumentList::CreateCopy(
4784 Reader.getContext(), TemplArgs);
4785
4786 // FIXME: If we already have a partial specialization set,
4787 // check that it matches.
4788 if (!isa<ClassTemplatePartialSpecializationDecl *>(
4789 Spec->getSpecializedTemplateOrPartial()))
4790 Spec->setInstantiationOf(PartialSpec, TemplArgList);
4791 }
4792 }
4793
4794 RD->setTagKind(static_cast<TagTypeKind>(Record.readInt()));
4795 RD->setLocation(readSourceLocation());
4796 RD->setLocStart(readSourceLocation());
4797 RD->setBraceRange(readSourceRange());
4798
4799 if (Record.readInt()) {
4800 AttrVec Attrs;
4801 Record.readAttributes(Attrs);
4802 // If the declaration already has attributes, we assume that some other
4803 // AST file already loaded them.
4804 if (!D->hasAttrs())
4805 D->setAttrsImpl(Attrs, Reader.getContext());
4806 }
4807 break;
4808 }
4809
4811 // Set the 'operator delete' directly to avoid emitting another update
4812 // record.
4813 auto *Del = readDeclAs<FunctionDecl>();
4814 auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
4815 auto *ThisArg = Record.readExpr();
4816 // FIXME: Check consistency if we have an old and new operator delete.
4817 if (!First->OperatorDelete) {
4818 First->OperatorDelete = Del;
4819 First->OperatorDeleteThisArg = ThisArg;
4820 }
4821 break;
4822 }
4823
4825 SmallVector<QualType, 8> ExceptionStorage;
4826 auto ESI = Record.readExceptionSpecInfo(ExceptionStorage);
4827
4828 // Update this declaration's exception specification, if needed.
4829 auto *FD = cast<FunctionDecl>(D);
4830 auto *FPT = FD->getType()->castAs<FunctionProtoType>();
4831 // FIXME: If the exception specification is already present, check that it
4832 // matches.
4833 if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
4834 FD->setType(Reader.getContext().getFunctionType(
4835 FPT->getReturnType(), FPT->getParamTypes(),
4836 FPT->getExtProtoInfo().withExceptionSpec(ESI)));
4837
4838 // When we get to the end of deserializing, see if there are other decls
4839 // that we need to propagate this exception specification onto.
4840 Reader.PendingExceptionSpecUpdates.insert(
4841 std::make_pair(FD->getCanonicalDecl(), FD));
4842 }
4843 break;
4844 }
4845
4847 auto *FD = cast<FunctionDecl>(D);
4848 QualType DeducedResultType = Record.readType();
4849 Reader.PendingDeducedTypeUpdates.insert(
4850 {FD->getCanonicalDecl(), DeducedResultType});
4851 break;
4852 }
4853
4855 // Maintain AST consistency: any later redeclarations are used too.
4856 D->markUsed(Reader.getContext());
4857 break;
4858
4860 Reader.getContext().setManglingNumber(cast<NamedDecl>(D),
4861 Record.readInt());
4862 break;
4863
4865 Reader.getContext().setStaticLocalNumber(cast<VarDecl>(D),
4866 Record.readInt());
4867 break;
4868
4870 D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(Reader.getContext(),
4871 readSourceRange()));
4872 break;
4873
4875 auto AllocatorKind =
4876 static_cast<OMPAllocateDeclAttr::AllocatorTypeTy>(Record.readInt());
4877 Expr *Allocator = Record.readExpr();
4878 Expr *Alignment = Record.readExpr();
4879 SourceRange SR = readSourceRange();
4880 D->addAttr(OMPAllocateDeclAttr::CreateImplicit(
4881 Reader.getContext(), AllocatorKind, Allocator, Alignment, SR));
4882 break;
4883 }
4884
4885 case UPD_DECL_EXPORTED: {
4886 unsigned SubmoduleID = readSubmoduleID();
4887 auto *Exported = cast<NamedDecl>(D);
4888 Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
4889 Reader.getContext().mergeDefinitionIntoModule(Exported, Owner);
4890 Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);
4891 break;
4892 }
4893
4895 auto MapType = Record.readEnum<OMPDeclareTargetDeclAttr::MapTypeTy>();
4896 auto DevType = Record.readEnum<OMPDeclareTargetDeclAttr::DevTypeTy>();
4897 Expr *IndirectE = Record.readExpr();
4898 bool Indirect = Record.readBool();
4899 unsigned Level = Record.readInt();
4900 D->addAttr(OMPDeclareTargetDeclAttr::CreateImplicit(
4901 Reader.getContext(), MapType, DevType, IndirectE, Indirect, Level,
4902 readSourceRange()));
4903 break;
4904 }
4905
4907 AttrVec Attrs;
4908 Record.readAttributes(Attrs);
4909 assert(Attrs.size() == 1);
4910 D->addAttr(Attrs[0]);
4911 break;
4912 }
4913 }
4914}
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3460
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)
#define NO_MERGE(Field)
static char ID
Definition: Arena.cpp:183
Defines the clang::attr::Kind enum.
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
Definition: CharUnits.h:225
const Decl * D
enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind
Expr * E
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.
unsigned Iter
Definition: HTMLLogger.cpp:153
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
Definition: MachO.h:31
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.
SourceLocation Loc
Definition: SemaObjC.cpp:759
bool Indirect
Definition: SemaObjC.cpp:760
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.
StateNode * Previous
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:438
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1141
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
Definition: ASTContext.h:834
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
Definition: ASTContext.h:754
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.
Definition: ASTContext.h:1681
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.
Definition: ASTContext.h:3268
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1274
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)
Definition: ASTContext.h:1101
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 UpdateDecl(Decl *D)
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 VisitDecl(Decl *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.
Definition: ASTReader.h:384
bool isDeclIDFromModule(GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
Definition: ASTReader.cpp:7995
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2546
Decl * ReadDecl(ModuleFile &F, const RecordDataImpl &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:2121
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...
Definition: ASTReader.cpp:8015
T * ReadDeclAs(ModuleFile &F, const RecordDataImpl &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:2131
SourceLocation ReadSourceLocation(ModuleFile &MF, RawLocEncoding Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
Definition: ASTReader.h:2415
LocalDeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, GlobalDeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
Definition: ASTReader.cpp:8215
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
Definition: ASTReader.cpp:7438
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.
Definition: ASTReader.cpp:8194
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:9594
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...
Definition: ASTReader.cpp:4584
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
SmallVector< uint64_t, 64 > RecordData
Definition: ASTReader.h:399
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.
Definition: ASTReader.cpp:7399
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 ':'.
Definition: DeclCXX.h:86
static AccessSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:60
Attr - This represents one attribute.
Definition: Attr.h:43
Attr * clone(ASTContext &C) const
Syntax
The style used to specify an attribute.
@ AS_Keyword
__ptr16, alignas(...), etc.
A binding in a decomposition declaration.
Definition: DeclCXX.h:4169
static BindingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3476
A simple helper class to unpack an integer to bits and consuming the bits in order.
Definition: ASTReader.h:2608
uint32_t getNextBits(uint32_t Width)
Definition: ASTReader.h:2631
A class which contains all the information about a particular captured value.
Definition: Decl.h:4502
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4496
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.cpp:5275
void setDoesNotEscape(bool B=true)
Definition: Decl.h:4648
void setSignatureAsWritten(TypeSourceInfo *Sig)
Definition: Decl.h:4578
void setCanAvoidCopyToHeap(bool B=true)
Definition: Decl.h:4653
void setIsConversionFromLambda(bool val=true)
Definition: Decl.h:4643
void setBlockMissingReturnType(bool val=true)
Definition: Decl.h:4635
static BlockDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5466
void setIsVariadic(bool value)
Definition: Decl.h:4572
void setBody(CompoundStmt *B)
Definition: Decl.h:4576
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
Definition: Decl.cpp:5286
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2592
static CXXConstructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, uint64_t AllocKind)
Definition: DeclCXX.cpp:2840
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2924
static CXXConversionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3041
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1967
static CXXDeductionGuideDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:2304
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2856
static CXXDestructorDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:2987
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2117
static CXXMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:2424
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:565
static CXXRecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:164
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
Definition: DeclCXX.cpp:1989
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:524
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4772
static CapturedDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
Definition: Decl.cpp:5509
void setContextParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:4838
void setNothrow(bool Nothrow=true)
Definition: Decl.cpp:5519
void setParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:4820
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.
Definition: ASTConcept.h:124
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3660
static ConstructorUsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3268
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1372
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1439
void setHasExternalVisibleStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations visible in this context.
Definition: DeclBase.h:2697
bool isTranslationUnit() const
Definition: DeclBase.h:2180
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:2010
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1435
bool isFunctionOrMethod() const
Definition: DeclBase.h:2156
bool isValid() const
Definition: DeclID.h:124
DeclID getRawValue() const
Definition: DeclID.h:118
bool isInvalid() const
Definition: DeclID.h:126
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:67
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:1054
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:1069
T * getAttr() const
Definition: DeclBase.h:576
bool hasAttrs() const
Definition: DeclBase.h:521
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:528
void setOwningModuleID(unsigned ID)
Set the owning module ID.
Definition: DeclBase.cpp:126
void addAttr(Attr *A)
Definition: DeclBase.cpp:1019
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
Definition: DeclBase.h:1144
void setTopLevelDeclInObjCContainer(bool V=true)
Definition: DeclBase.h:635
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:572
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:977
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:835
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: DeclBase.h:1063
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
Definition: DeclBase.h:805
ObjCDeclQualifier
ObjCDeclQualifier - 'Qualifiers' written next to the return and parameter types in method declaration...
Definition: DeclBase.h:198
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:786
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2784
bool isInvalidDecl() const
Definition: DeclBase.h:591
unsigned FromASTFile
Whether this declaration was loaded from an AST file.
Definition: DeclBase.h:340
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:505
SourceLocation getLocation() const
Definition: DeclBase.h:442
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
Definition: DeclBase.h:115
@ IDNS_Ordinary
Ordinary names.
Definition: DeclBase.h:144
@ IDNS_Type
Types, declared with 'struct foo', typedefs, etc.
Definition: DeclBase.h:130
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
Definition: DeclBase.h:125
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack.
Definition: DeclBase.cpp:237
void setImplicit(bool I=true)
Definition: DeclBase.h:597
void setReferenced(bool R=true)
Definition: DeclBase.h:626
void setLocation(SourceLocation L)
Definition: DeclBase.h:443
DeclContext * getDeclContext()
Definition: DeclBase.h:451
void setCachedLinkage(Linkage L) const
Definition: DeclBase.h:420
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:363
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:911
bool hasAttr() const
Definition: DeclBase.h:580
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:971
ModuleOwnershipKind
The kind of ownership a declaration has, for visibility purposes.
Definition: DeclBase.h:216
@ 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...
Kind getKind() const
Definition: DeclBase.h:445
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:874
bool shouldEmitInExternalSource() const
Whether the definition of the declaration should be emitted in external sources.
Definition: DeclBase.cpp:1157
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible.
Definition: DeclBase.h:863
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.
Definition: Decl.h:735
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:778
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:769
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:764
A decomposition declaration.
Definition: DeclCXX.h:4228
static DecompositionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumBindings)
Definition: DeclCXX.cpp:3506
bool isDeduced() const
Definition: Type.h:6550
Represents an empty-declaration.
Definition: Decl.h:5011
static EmptyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5707
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3291
static EnumConstantDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5535
void setInitExpr(Expr *E)
Definition: Decl.h:3315
void setInitVal(const ASTContext &C, const llvm::APSInt &V)
Definition: Decl.h:3316
Represents an enum.
Definition: Decl.h:3861
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
Definition: Decl.h:4120
void setFixed(bool Fixed=true)
True if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying type.
Definition: Decl.h:3932
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:4030
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition: Decl.h:4033
unsigned getODRHash()
Definition: Decl.cpp:4995
static EnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:4908
void setScoped(bool Scoped=true)
True if this tag declaration is a scoped enumeration.
Definition: Decl.h:3920
void setPromotionType(QualType T)
Set the promotion type.
Definition: Decl.h:4016
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:3942
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...
Definition: Decl.h:3926
Represents a standard C++ module export declaration.
Definition: Decl.h:4964
static ExportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5830
This represents one expression.
Definition: Expr.h:110
Represents a member of a struct/union/class.
Definition: Decl.h:3033
void setBitWidth(Expr *Width)
Set the bit-field width for this member.
Definition: Decl.h:3163
static FieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:4583
const VariableArrayType * CapturedVLAType
Definition: Decl.h:3089
void setRParenLoc(SourceLocation L)
Definition: Decl.h:4441
void setAsmString(StringLiteral *Asm)
Definition: Decl.h:4448
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5667
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Definition: DeclFriend.h:54
static FriendDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned FriendTypeNumTPLists)
Definition: DeclFriend.cpp:63
Declaration of a friend template.
static FriendTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Definition: Decl.cpp:3103
Represents a function declaration or definition.
Definition: Decl.h:1935
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:4072
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:4067
void setIsPureVirtual(bool P=true)
Definition: Decl.cpp:3262
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
Definition: Decl.cpp:3124
void setFriendConstraintRefersToEnclosingTemplate(bool V=true)
Definition: Decl.h:2577
void setHasSkippedBody(bool Skipped=true)
Definition: Decl.h:2556
static FunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5456
void setUsesSEHTry(bool UST)
Definition: Decl.h:2447
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
Definition: Decl.h:2571
void setHasWrittenPrototype(bool P=true)
State that this function has a written prototype.
Definition: Decl.h:2381
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
Definition: Decl.h:2317
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
Definition: Decl.cpp:4046
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:4197
void setDefaultLoc(SourceLocation NewLoc)
Definition: Decl.h:2330
void setInlineSpecified(bool I)
Set whether the "inline" keyword was specified for this function.
Definition: Decl.h:2777
TemplatedKind
The kind of templated function a FunctionDecl can be.
Definition: Decl.h:1940
@ TK_MemberSpecialization
Definition: Decl.h:1947
@ TK_DependentNonTemplate
Definition: Decl.h:1956
@ TK_FunctionTemplateSpecialization
Definition: Decl.h:1951
@ TK_DependentFunctionTemplateSpecialization
Definition: Decl.h:1954
void setTrivial(bool IT)
Definition: Decl.h:2306
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:4018
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
Definition: Decl.cpp:4085
bool isDeletedAsWritten() const
Definition: Decl.h:2472
void setHasInheritedPrototype(bool P=true)
State that this function inherited its prototype from a previous declaration.
Definition: Decl.h:2393
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
Definition: Decl.cpp:4252
void setVirtualAsWritten(bool V)
State that this function is marked as virtual explicitly.
Definition: Decl.h:2284
void setLateTemplateParsed(bool ILT=true)
State that this templated function will be late parsed.
Definition: Decl.h:2297
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition: Decl.h:2791
void setTrivialForCall(bool IT)
Definition: Decl.h:2309
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2313
void setIneligibleOrNotSelected(bool II)
Definition: Decl.h:2349
void setConstexprKind(ConstexprSpecKind CSK)
Definition: Decl.h:2401
void setDefaulted(bool D=true)
Definition: Decl.h:2314
void setStorageClass(StorageClass SClass)
Sets the storage class as written in the source.
Definition: Decl.h:2768
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
Definition: Decl.cpp:3133
void setExplicitlyDefaulted(bool ED=true)
State that this function is explicitly defaulted.
Definition: Decl.h:2322
void setHasImplicitReturnZero(bool IRZ)
State that falling off this function implicitly returns null/zero.
Definition: Decl.h:2363
Represents a prototype with parameter type info, e.g.
Definition: Type.h:5108
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:5388
Declaration of a template function.
Definition: DeclTemplate.h:958
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 ...
Definition: DeclTemplate.h:471
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)
Definition: DeclTemplate.h:603
FunctionDecl * getFunction() const
Retrieve the declaration of the function template specialization.
Definition: DeclTemplate.h:523
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:4322
QualType getReturnType() const
Definition: Type.h:4649
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
Definition: Decl.h:5026
static HLSLBufferDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5740
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)
Definition: Decl.cpp:5437
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4885
static ImportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
Definition: Decl.cpp:5797
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3335
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5562
void setInherited(bool I)
Definition: Attr.h:155
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2563
Represents the declaration of a label.
Definition: Decl.h:503
static LabelDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5397
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
LambdaCaptureKind getCaptureKind() const
Determine the kind of capture.
Definition: ExprCXX.cpp:1245
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Definition: DeclCXX.h:3291
unsigned getManglingNumber() const
Definition: DeclCXX.h:3340
static LifetimeExtendedTemporaryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.h:3321
Represents a linkage specification.
Definition: DeclCXX.h:2996
static LinkageSpecDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3087
Represents the results of name lookup.
Definition: Lookup.h:46
A global _GUID constant.
Definition: DeclCXX.h:4351
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4297
static MSPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3545
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:619
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:664
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Definition: Redeclarable.h:313
Describes a module or submodule.
Definition: Module.h:115
@ AllVisible
All of the names in this module are visible.
Definition: Module.h:418
std::string Name
The name of this module.
Definition: Module.h:118
bool isGlobalModule() const
Does this Module scope describe a fragment of the global module within some C++ module.
Definition: Module.h:210
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:129
bool isNamedModule() const
Does this Module is a named module of a standard named module?
Definition: Module.h:195
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:693
This represents a decl that may have a name.
Definition: Decl.h:253
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:274
bool isPlaceholderVar(const LangOptions &LangOpts) const
Definition: Decl.cpp:1089
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:319
void setDeclName(DeclarationName N)
Set the name of this declaration.
Definition: Decl.h:322
Represents a C++ namespace alias.
Definition: DeclCXX.h:3182
static NamespaceAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3188
Represent a C++ namespace.
Definition: Decl.h:551
static NamespaceDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3142
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.
Definition: DeclOpenMP.h:474
static OMPAllocateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NVars, unsigned NClauses)
Definition: DeclOpenMP.cpp:66
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:383
static OMPCapturedExprDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclOpenMP.cpp:183
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:287
static OMPDeclareMapperDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Creates deserialized declare mapper node.
Definition: DeclOpenMP.cpp:152
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:177
static OMPDeclareReductionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create deserialized declare reduction node.
Definition: DeclOpenMP.cpp:122
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:417
static OMPRequiresDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Create deserialized requires node.
Definition: DeclOpenMP.cpp:93
This represents '#pragma omp threadprivate ...' directive.
Definition: DeclOpenMP.h:110
static OMPThreadPrivateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned N)
Definition: DeclOpenMP.cpp:38
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:2029
static ObjCAtDefsFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:1915
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2328
void setProtocolList(ObjCProtocolDecl *const *List, unsigned Num, const SourceLocation *Locs, ASTContext &C)
setProtocolList - Set the list of protocols that this interface implements.
Definition: DeclObjC.h:2390
static ObjCCategoryDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2149
void setIvarLBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2462
void setCategoryNameLoc(SourceLocation Loc)
Definition: DeclObjC.h:2460
void setIvarRBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2464
bool IsClassExtension() const
Definition: DeclObjC.h:2436
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Definition: DeclObjC.h:2544
static ObjCCategoryImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2191
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2774
static ObjCCompatibleAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2341
void setClassInterface(ObjCInterfaceDecl *D)
Definition: DeclObjC.h:2794
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:947
void setAtStartLoc(SourceLocation Loc)
Definition: DeclObjC.h:1097
void setAtEndRange(SourceRange atEnd)
Definition: DeclObjC.h:1104
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2596
static ObjCImplementationDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2298
Represents an ObjC class declaration.
Definition: DeclObjC.h:1153
void mergeClassExtensionProtocolList(ObjCProtocolDecl *const *List, unsigned Num, ASTContext &C)
mergeClassExtensionProtocolList - Merge class extension's protocol list into the protocol list for th...
Definition: DeclObjC.cpp:440
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:635
static ObjCInterfaceDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:1552
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1914
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1951
void setAccessControl(AccessControl ac)
Definition: DeclObjC.h:1997
void setNextIvar(ObjCIvarDecl *ivar)
Definition: DeclObjC.h:1988
ObjCInterfaceDecl * getContainingInterface()
Return the class interface that this ivar is logically contained in; this is either the interface whe...
Definition: DeclObjC.cpp:1873
void setSynthesize(bool synth)
Definition: DeclObjC.h:2005
static ObjCIvarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:1867
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:140
void setSynthesizedAccessorStub(bool isSynthesizedAccessorStub)
Definition: DeclObjC.h:448
void setObjCDeclQualifier(ObjCDeclQualifier QV)
Definition: DeclObjC.h:250
void setDefined(bool isDefined)
Definition: DeclObjC.h:453
void setSelfDecl(ImplicitParamDecl *SD)
Definition: DeclObjC.h:419
void setReturnTypeSourceInfo(TypeSourceInfo *TInfo)
Definition: DeclObjC.h:344
void setHasRedeclaration(bool HRD) const
Definition: DeclObjC.h:272
void setIsRedeclaration(bool RD)
Definition: DeclObjC.h:267
void setCmdDecl(ImplicitParamDecl *CD)
Definition: DeclObjC.h:421
bool hasRedeclaration() const
True if redeclared in the same interface.
Definition: DeclObjC.h:271
void setRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
Definition: DeclObjC.h:261
void setOverriding(bool IsOver)
Definition: DeclObjC.h:463
void setPropertyAccessor(bool isAccessor)
Definition: DeclObjC.h:440
void setDeclImplementation(ObjCImplementationControl ic)
Definition: DeclObjC.h:496
void setReturnType(QualType T)
Definition: DeclObjC.h:330
static ObjCMethodDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:863
void setHasSkippedBody(bool Skipped=true)
Definition: DeclObjC.h:478
void setInstanceMethod(bool isInst)
Definition: DeclObjC.h:427
void setVariadic(bool isVar)
Definition: DeclObjC.h:432
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:730
static ObjCPropertyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2361
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2804
static ObjCPropertyImplDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:2395
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2083
static ObjCProtocolDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclObjC.cpp:1950
ObjCProtocolDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C protocol.
Definition: DeclObjC.h:2296
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:578
static ObjCTypeParamDecl * CreateDeserialized(ASTContext &ctx, GlobalDeclID ID)
Definition: DeclObjC.cpp:1487
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:659
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
Definition: DeclObjC.cpp:1518
Represents a partial function definition.
Definition: Decl.h:4703
static OutlinedFunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
Definition: Decl.cpp:5483
Represents a parameter to a function.
Definition: Decl.h:1725
static ParmVarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:2939
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:3012
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1758
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1753
Represents a #pragma comment line.
Definition: Decl.h:146
static PragmaCommentDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned ArgSize)
Definition: Decl.cpp:5344
Represents a #pragma detect_mismatch line.
Definition: Decl.h:180
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NameValueSize)
Definition: Decl.cpp:5370
A (possibly-)qualified type.
Definition: Type.h:929
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:996
const Type * getTypePtrOrNull() const
Definition: Type.h:7941
Represents a struct/union/class.
Definition: Decl.h:4162
unsigned getODRHash()
Get precomputed ODRHash or add a new one.
Definition: Decl.cpp:5247
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:4218
void setArgPassingRestrictions(RecordArgPassingKind Kind)
Definition: Decl.h:4308
void setNonTrivialToPrimitiveCopy(bool V)
Definition: Decl.h:4252
void setHasNonTrivialToPrimitiveCopyCUnion(bool V)
Definition: Decl.h:4284
void setHasNonTrivialToPrimitiveDestructCUnion(bool V)
Definition: Decl.h:4276
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:4199
void setParamDestroyedInCallee(bool V)
Definition: Decl.h:4316
void setNonTrivialToPrimitiveDestroy(bool V)
Definition: Decl.h:4260
void setHasObjectMember(bool val)
Definition: Decl.h:4223
void setHasVolatileMember(bool val)
Definition: Decl.h:4227
void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V)
Definition: Decl.h:4268
static RecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5071
void setHasUninitializedExplicitInitFields(bool V)
Definition: Decl.h:4292
void setNonTrivialToPrimitiveDefaultInitialize(bool V)
Definition: Decl.h:4244
Declaration of a redeclarable template.
Definition: DeclTemplate.h:720
CommonBase * Common
Pointer to the common data shared by all declarations of this template.
Definition: DeclTemplate.h:811
virtual CommonBase * newCommon(ASTContext &C) const =0
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:84
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: Redeclarable.h:222
static DeclLink PreviousDeclLink(decl_type *D)
Definition: Redeclarable.h:164
Represents the body of a requires-expression.
Definition: DeclCXX.h:2086
static RequiresExprBodyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:2319
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.
Definition: DeclCXX.h:4120
static StaticAssertDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3453
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1778
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3578
void setTagKind(TagKind TK)
Definition: Decl.h:3777
void setCompleteDefinitionRequired(bool V=true)
True if this complete decl is required to be complete for some existing use.
Definition: Decl.h:3696
void demoteThisDefinitionToDeclaration()
Mark a definition as a declaration and maintain information it was a definition.
Definition: Decl.h:3745
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
Definition: Decl.h:3676
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
Definition: Decl.h:3711
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3681
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:4770
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
Definition: Decl.h:3719
void setBraceRange(SourceRange R)
Definition: Decl.h:3658
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
Definition: Decl.h:3684
A convenient class for passing around template argument information.
Definition: TemplateBase.h:632
A template argument list.
Definition: DeclTemplate.h:250
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.).
Definition: DeclTemplate.h:398
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:430
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:417
A template parameter object.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
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.
Definition: Decl.h:4459
static TopLevelStmtDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5685
The top declaration context.
Definition: Decl.h:84
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3549
static TypeAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5636
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:3568
Declaration of an alias template.
static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Create an empty alias template node.
Represents a declaration of a type.
Definition: Decl.h:3384
void setLocStart(SourceLocation L)
Definition: Decl.h:3413
A container of type source information.
Definition: Type.h:7908
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:7919
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8810
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.h:2812
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.cpp:2045
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8741
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition: Decl.h:3528
static TypedefDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5623
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3427
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition: Decl.h:3492
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:3488
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Definition: DeclCXX.h:4408
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
A set of unresolved declarations.
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
Definition: DeclCXX.h:4102
static UnresolvedUsingIfExistsDecl * CreateDeserialized(ASTContext &Ctx, GlobalDeclID ID)
Definition: DeclCXX.cpp:3429
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:4021
static UnresolvedUsingTypenameDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3415
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3924
static UnresolvedUsingValueDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3385
Represents a C++ using-declaration.
Definition: DeclCXX.h:3574
static UsingDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3316
Represents C++ using-directive.
Definition: DeclCXX.h:3077
static UsingDirectiveDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3109
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3775
static UsingEnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3340
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Definition: DeclCXX.h:3856
static UsingPackDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumExpansions)
Definition: DeclCXX.cpp:3360
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3382
static UsingShadowDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: DeclCXX.cpp:3244
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:671
void setType(QualType newType)
Definition: Decl.h:683
Represents a variable declaration or definition.
Definition: Decl.h:882
ParmVarDeclBitfields ParmVarDeclBits
Definition: Decl.h:1075
static VarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:2146
VarDeclBitfields VarDeclBits
Definition: Decl.h:1074
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
Definition: Decl.cpp:2529
NonParmVarDeclBitfields NonParmVarDeclBits
Definition: Decl.h:1076
@ Definition
This declaration is definitely a definition.
Definition: Decl.h:1252
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2791
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1119
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)
RetTy Visit(PTR(Decl) D)
Definition: DeclVisitor.h:37
Source location and bit offset of a declaration.
Definition: ASTBitCodes.h:252
RawLocEncoding getRawLoc() const
Definition: ASTBitCodes.h:271
uint64_t getBitOffset(const uint64_t DeclTypesBlockStartOffset) const
Definition: ASTBitCodes.h:277
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:130
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID.
Definition: ModuleFile.h:469
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
Definition: ModuleFile.h:472
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:448
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
Definition: ModuleFile.h:216
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
Definition: ModuleFile.h:458
unsigned Generation
The generation of which this module file is a part.
Definition: ModuleFile.h:206
uint64_t DeclsBlockStartOffset
The offset to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:451
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
Definition: ModuleFile.h:476
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.
Definition: ASTBitCodes.h:1223
DeclCode
Record codes for each kind of declaration.
Definition: ASTBitCodes.h:1231
const unsigned int DECL_UPDATES
Record of updates for a declaration that was modified after being deserialized.
Definition: ASTBitCodes.h:1219
@ DECL_EMPTY
An EmptyDecl record.
Definition: ASTBitCodes.h:1490
@ DECL_CAPTURED
A CapturedDecl record.
Definition: ASTBitCodes.h:1323
@ DECL_CXX_BASE_SPECIFIERS
A record containing CXXBaseSpecifiers.
Definition: ASTBitCodes.h:1461
@ DECL_CXX_RECORD
A CXXRecordDecl record.
Definition: ASTBitCodes.h:1392
@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
A VarTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1434
@ DECL_OMP_ALLOCATE
An OMPAllocateDcl record.
Definition: ASTBitCodes.h:1487
@ DECL_MS_PROPERTY
A MSPropertyDecl record.
Definition: ASTBitCodes.h:1287
@ DECL_OMP_DECLARE_MAPPER
An OMPDeclareMapperDecl record.
Definition: ASTBitCodes.h:1511
@ DECL_TOP_LEVEL_STMT_DECL
A TopLevelStmtDecl record.
Definition: ASTBitCodes.h:1314
@ DECL_REQUIRES_EXPR_BODY
A RequiresExprBodyDecl record.
Definition: ASTBitCodes.h:1496
@ DECL_STATIC_ASSERT
A StaticAssertDecl record.
Definition: ASTBitCodes.h:1458
@ DECL_INDIRECTFIELD
A IndirectFieldDecl record.
Definition: ASTBitCodes.h:1467
@ DECL_TEMPLATE_TEMPLATE_PARM
A TemplateTemplateParmDecl record.
Definition: ASTBitCodes.h:1446
@ DECL_IMPORT
An ImportDecl recording a module import.
Definition: ASTBitCodes.h:1478
@ DECL_UNNAMED_GLOBAL_CONSTANT
A UnnamedGlobalConstantDecl record.
Definition: ASTBitCodes.h:1517
@ DECL_ACCESS_SPEC
An AccessSpecDecl record.
Definition: ASTBitCodes.h:1410
@ DECL_OBJC_TYPE_PARAM
An ObjCTypeParamDecl record.
Definition: ASTBitCodes.h:1499
@ DECL_OBJC_CATEGORY_IMPL
A ObjCCategoryImplDecl record.
Definition: ASTBitCodes.h:1269
@ DECL_ENUM_CONSTANT
An EnumConstantDecl record.
Definition: ASTBitCodes.h:1245
@ DECL_PARM_VAR
A ParmVarDecl record.
Definition: ASTBitCodes.h:1302
@ DECL_TYPEDEF
A TypedefDecl record.
Definition: ASTBitCodes.h:1233
@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.
Definition: ASTBitCodes.h:1475
@ DECL_HLSL_BUFFER
A HLSLBufferDecl record.
Definition: ASTBitCodes.h:1520
@ DECL_NAMESPACE_ALIAS
A NamespaceAliasDecl record.
Definition: ASTBitCodes.h:1359
@ DECL_TYPEALIAS
A TypeAliasDecl record.
Definition: ASTBitCodes.h:1236
@ DECL_FUNCTION_TEMPLATE
A FunctionTemplateDecl record.
Definition: ASTBitCodes.h:1437
@ DECL_MS_GUID
A MSGuidDecl record.
Definition: ASTBitCodes.h:1290
@ DECL_UNRESOLVED_USING_TYPENAME
An UnresolvedUsingTypenameDecl record.
Definition: ASTBitCodes.h:1383
@ DECL_CLASS_TEMPLATE_SPECIALIZATION
A ClassTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1422
@ DECL_FILE_SCOPE_ASM
A FileScopeAsmDecl record.
Definition: ASTBitCodes.h:1311
@ DECL_CXX_CONSTRUCTOR
A CXXConstructorDecl record.
Definition: ASTBitCodes.h:1401
@ DECL_CXX_CONVERSION
A CXXConversionDecl record.
Definition: ASTBitCodes.h:1407
@ DECL_FIELD
A FieldDecl record.
Definition: ASTBitCodes.h:1284
@ DECL_LINKAGE_SPEC
A LinkageSpecDecl record.
Definition: ASTBitCodes.h:1386
@ DECL_CONTEXT_TU_LOCAL_VISIBLE
A record that stores the set of declarations that are only visible to the TU.
Definition: ASTBitCodes.h:1350
@ DECL_NAMESPACE
A NamespaceDecl record.
Definition: ASTBitCodes.h:1356
@ DECL_NON_TYPE_TEMPLATE_PARM
A NonTypeTemplateParmDecl record.
Definition: ASTBitCodes.h:1443
@ DECL_USING_PACK
A UsingPackDecl record.
Definition: ASTBitCodes.h:1368
@ DECL_FUNCTION
A FunctionDecl record.
Definition: ASTBitCodes.h:1248
@ DECL_USING_DIRECTIVE
A UsingDirecitveDecl record.
Definition: ASTBitCodes.h:1377
@ DECL_RECORD
A RecordDecl record.
Definition: ASTBitCodes.h:1242
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
Definition: ASTBitCodes.h:1333
@ DECL_OUTLINEDFUNCTION
A OutlinedFunctionDecl record.
Definition: ASTBitCodes.h:1320
@ DECL_BLOCK
A BlockDecl record.
Definition: ASTBitCodes.h:1317
@ DECL_UNRESOLVED_USING_VALUE
An UnresolvedUsingValueDecl record.
Definition: ASTBitCodes.h:1380
@ DECL_TYPE_ALIAS_TEMPLATE
A TypeAliasTemplateDecl record.
Definition: ASTBitCodes.h:1449
@ DECL_CXX_CTOR_INITIALIZERS
A record containing CXXCtorInitializers.
Definition: ASTBitCodes.h:1464
@ DECL_OBJC_CATEGORY
A ObjCCategoryDecl record.
Definition: ASTBitCodes.h:1266
@ DECL_VAR
A VarDecl record.
Definition: ASTBitCodes.h:1296
@ DECL_UNRESOLVED_USING_IF_EXISTS
An UnresolvedUsingIfExistsDecl record.
Definition: ASTBitCodes.h:1455
@ DECL_USING
A UsingDecl record.
Definition: ASTBitCodes.h:1362
@ DECL_OBJC_PROTOCOL
A ObjCProtocolDecl record.
Definition: ASTBitCodes.h:1257
@ DECL_TEMPLATE_TYPE_PARM
A TemplateTypeParmDecl record.
Definition: ASTBitCodes.h:1440
@ DECL_VAR_TEMPLATE_SPECIALIZATION
A VarTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1431
@ DECL_OBJC_IMPLEMENTATION
A ObjCImplementationDecl record.
Definition: ASTBitCodes.h:1272
@ DECL_LABEL
A LabelDecl record.
Definition: ASTBitCodes.h:1353
@ DECL_OBJC_COMPATIBLE_ALIAS
A ObjCCompatibleAliasDecl record.
Definition: ASTBitCodes.h:1275
@ DECL_CONSTRUCTOR_USING_SHADOW
A ConstructorUsingShadowDecl record.
Definition: ASTBitCodes.h:1374
@ DECL_USING_ENUM
A UsingEnumDecl record.
Definition: ASTBitCodes.h:1365
@ DECL_FRIEND_TEMPLATE
A FriendTemplateDecl record.
Definition: ASTBitCodes.h:1416
@ DECL_PRAGMA_DETECT_MISMATCH
A PragmaDetectMismatchDecl record.
Definition: ASTBitCodes.h:1508
@ DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK
A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack.
Definition: ASTBitCodes.h:1471
@ DECL_OBJC_AT_DEFS_FIELD
A ObjCAtDefsFieldDecl record.
Definition: ASTBitCodes.h:1263
@ DECL_IMPLICIT_PARAM
An ImplicitParamDecl record.
Definition: ASTBitCodes.h:1299
@ DECL_FRIEND
A FriendDecl record.
Definition: ASTBitCodes.h:1413
@ DECL_CXX_METHOD
A CXXMethodDecl record.
Definition: ASTBitCodes.h:1398
@ DECL_EXPORT
An ExportDecl record.
Definition: ASTBitCodes.h:1389
@ DECL_BINDING
A BindingDecl record.
Definition: ASTBitCodes.h:1308
@ DECL_PRAGMA_COMMENT
A PragmaCommentDecl record.
Definition: ASTBitCodes.h:1505
@ DECL_ENUM
An EnumDecl record.
Definition: ASTBitCodes.h:1239
@ DECL_CONTEXT_MODULE_LOCAL_VISIBLE
A record containing the set of declarations that are only visible from DeclContext in the same module...
Definition: ASTBitCodes.h:1346
@ DECL_DECOMPOSITION
A DecompositionDecl record.
Definition: ASTBitCodes.h:1305
@ DECL_OMP_DECLARE_REDUCTION
An OMPDeclareReductionDecl record.
Definition: ASTBitCodes.h:1514
@ DECL_OMP_THREADPRIVATE
An OMPThreadPrivateDecl record.
Definition: ASTBitCodes.h:1481
@ DECL_OBJC_METHOD
A ObjCMethodDecl record.
Definition: ASTBitCodes.h:1251
@ DECL_CXX_DESTRUCTOR
A CXXDestructorDecl record.
Definition: ASTBitCodes.h:1404
@ DECL_OMP_CAPTUREDEXPR
An OMPCapturedExprDecl record.
Definition: ASTBitCodes.h:1502
@ DECL_CLASS_TEMPLATE
A ClassTemplateDecl record.
Definition: ASTBitCodes.h:1419
@ DECL_USING_SHADOW
A UsingShadowDecl record.
Definition: ASTBitCodes.h:1371
@ DECL_CONCEPT
A ConceptDecl record.
Definition: ASTBitCodes.h:1452
@ DECL_CXX_DEDUCTION_GUIDE
A CXXDeductionGuideDecl record.
Definition: ASTBitCodes.h:1395
@ DECL_OMP_REQUIRES
An OMPRequiresDecl record.
Definition: ASTBitCodes.h:1484
@ DECL_OBJC_IVAR
A ObjCIvarDecl record.
Definition: ASTBitCodes.h:1260
@ DECL_OBJC_PROPERTY
A ObjCPropertyDecl record.
Definition: ASTBitCodes.h:1278
@ DECL_TEMPLATE_PARAM_OBJECT
A TemplateParamObjectDecl record.
Definition: ASTBitCodes.h:1293
@ DECL_OBJC_INTERFACE
A ObjCInterfaceDecl record.
Definition: ASTBitCodes.h:1254
@ DECL_VAR_TEMPLATE
A VarTemplateDecl record.
Definition: ASTBitCodes.h:1428
@ DECL_LIFETIME_EXTENDED_TEMPORARY
An LifetimeExtendedTemporaryDecl record.
Definition: ASTBitCodes.h:1493
@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
A ClassTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1425
@ DECL_IMPLICIT_CONCEPT_SPECIALIZATION
An ImplicitConceptSpecializationDecl record.
Definition: ASTBitCodes.h:1523
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1342
@ DECL_OBJC_PROPERTY_IMPL
A ObjCPropertyImplDecl record.
Definition: ASTBitCodes.h:1281
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.
Definition: Primitives.h:25
uint64_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:88
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:185
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:474
void numberAnonymousDeclsWithin(const DeclContext *DC, Fn Visit)
Visit each declaration within DC that needs an anonymous declaration number and call Visit with the d...
Definition: ASTCommon.h:72
bool isPartOfPerModuleInitializer(const Decl *D)
Determine whether the given declaration will be included in the per-module initializer if it needs to...
Definition: ASTCommon.h:92
@ UPD_CXX_INSTANTIATED_DEFAULT_MEMBER_INITIALIZER
Definition: ASTCommon.h:33
@ UPD_DECL_MARKED_OPENMP_DECLARETARGET
Definition: ASTCommon.h:42
@ UPD_CXX_POINT_OF_INSTANTIATION
Definition: ASTCommon.h:30
@ UPD_CXX_RESOLVED_EXCEPTION_SPEC
Definition: ASTCommon.h:35
@ UPD_CXX_ADDED_FUNCTION_DEFINITION
Definition: ASTCommon.h:28
@ UPD_DECL_MARKED_OPENMP_THREADPRIVATE
Definition: ASTCommon.h:40
@ UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT
Definition: ASTCommon.h:32
@ UPD_DECL_MARKED_OPENMP_ALLOCATE
Definition: ASTCommon.h:41
@ UPD_CXX_ADDED_ANONYMOUS_NAMESPACE
Definition: ASTCommon.h:27
@ UPD_CXX_INSTANTIATED_CLASS_DEFINITION
Definition: ASTCommon.h:31
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.
PragmaMSCommentKind
Definition: PragmaKinds.h:14
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition: Specifiers.h:35
LinkageSpecLanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2988
LazyOffsetPtr< Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt > LazyDeclStmtPtr
A lazy pointer to a statement.
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:33
@ LCK_ByCopy
Capturing by copy (a.k.a., by value)
Definition: Lambda.h:36
@ LCK_ByRef
Capturing by reference.
Definition: Lambda.h:37
@ LCK_VLAType
Capturing variable-length array type.
Definition: Lambda.h:38
@ LCK_StarThis
Capturing the *this object by copy.
Definition: Lambda.h:35
@ LCK_This
Capturing the *this object by reference.
Definition: Lambda.h:34
OMPDeclareReductionInitKind
Definition: DeclOpenMP.h:161
StorageClass
Storage classes.
Definition: Specifiers.h:248
@ SC_Extern
Definition: Specifiers.h:251
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:24
@ 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.
Definition: Type.h:6877
ObjCImplementationControl
Definition: DeclObjC.h:118
RecordArgPassingKind
Enum that represents the different ways arguments are passed to and returned from function calls.
Definition: Decl.h:4139
static bool isUndeducedReturnType(QualType T)
bool operator!=(CanQual< T > x, CanQual< U > y)
@ LCD_None
Definition: Lambda.h:23
for(const auto &A :T->param_types())
const FunctionProtoType * T
DeductionCandidate
Only used by CXXDeductionGuideDecl.
Definition: DeclBase.h:1411
bool shouldSkipCheckingODR(const Decl *D)
Definition: ASTReader.h:2650
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1278
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:188
@ 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...
Definition: Specifiers.h:123
unsigned long uint64_t
Structure used to store a statement, the constant value to which it was evaluated (if any),...
Definition: Decl.h:847
bool HasConstantDestruction
Whether this variable is known to have constant destruction.
Definition: Decl.h:865
bool WasEvaluated
Whether this statement was already evaluated.
Definition: Decl.h:849
LazyDeclStmtPtr Value
Definition: Decl.h:872
APValue Evaluated
Definition: Decl.h:873
bool HasConstantInitialization
Whether this variable is known to have constant initialization.
Definition: Decl.h:858
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.
Definition: DeclTemplate.h:964
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
Definition: DeclTemplate.h:967
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:708
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.
Definition: ASTBitCodes.h:2083