clang  3.9.0
ASTReaderDecl.cpp
Go to the documentation of this file.
1 //===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the ASTReader::ReadDeclRecord method, which is the
11 // entrypoint for loading a decl.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "ASTCommon.h"
17 #include "ASTReaderInternals.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclGroup.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/DeclVisitor.h"
24 #include "clang/AST/Expr.h"
27 #include "llvm/Support/SaveAndRestore.h"
28 
29 using namespace clang;
30 using namespace clang::serialization;
31 
32 //===----------------------------------------------------------------------===//
33 // Declaration deserialization
34 //===----------------------------------------------------------------------===//
35 
36 namespace clang {
37  class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
38  ASTReader &Reader;
39  ModuleFile &F;
40  uint64_t Offset;
41  const DeclID ThisDeclID;
42  const SourceLocation ThisDeclLoc;
44  const RecordData &Record;
45  unsigned &Idx;
46  TypeID TypeIDForTypeDecl;
47  unsigned AnonymousDeclNumber;
48  GlobalDeclID NamedDeclForTagDecl;
49  IdentifierInfo *TypedefNameForLinkage;
50 
51  bool HasPendingBody;
52 
53  ///\brief A flag to carry the information for a decl from the entity is
54  /// used. We use it to delay the marking of the canonical decl as used until
55  /// the entire declaration is deserialized and merged.
56  bool IsDeclMarkedUsed;
57 
58  uint64_t GetCurrentCursorOffset();
59 
60  uint64_t ReadLocalOffset(const RecordData &R, unsigned &I) {
61  uint64_t LocalOffset = R[I++];
62  assert(LocalOffset < Offset && "offset point after current record");
63  return LocalOffset ? Offset - LocalOffset : 0;
64  }
65 
66  uint64_t ReadGlobalOffset(ModuleFile &F, const RecordData &R, unsigned &I) {
67  uint64_t Local = ReadLocalOffset(R, I);
68  return Local ? Reader.getGlobalBitOffset(F, Local) : 0;
69  }
70 
71  SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
72  return Reader.ReadSourceLocation(F, R, I);
73  }
74 
75  SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
76  return Reader.ReadSourceRange(F, R, I);
77  }
78 
79  TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
80  return Reader.GetTypeSourceInfo(F, R, I);
81  }
82 
83  serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
84  return Reader.ReadDeclID(F, R, I);
85  }
86 
87  std::string ReadString(const RecordData &R, unsigned &I) {
88  return Reader.ReadString(R, I);
89  }
90 
91  void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
92  for (unsigned I = 0, Size = Record[Idx++]; I != Size; ++I)
93  IDs.push_back(ReadDeclID(Record, Idx));
94  }
95 
96  Decl *ReadDecl(const RecordData &R, unsigned &I) {
97  return Reader.ReadDecl(F, R, I);
98  }
99 
100  template<typename T>
101  T *ReadDeclAs(const RecordData &R, unsigned &I) {
102  return Reader.ReadDeclAs<T>(F, R, I);
103  }
104 
105  void ReadQualifierInfo(QualifierInfo &Info,
106  const RecordData &R, unsigned &I) {
107  Reader.ReadQualifierInfo(F, Info, R, I);
108  }
109 
110  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
111  const RecordData &R, unsigned &I) {
112  Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
113  }
114 
115  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
116  const RecordData &R, unsigned &I) {
117  Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
118  }
119 
120  serialization::SubmoduleID readSubmoduleID(const RecordData &R,
121  unsigned &I) {
122  if (I >= R.size())
123  return 0;
124 
125  return Reader.getGlobalSubmoduleID(F, R[I++]);
126  }
127 
128  Module *readModule(const RecordData &R, unsigned &I) {
129  return Reader.getSubmodule(readSubmoduleID(R, I));
130  }
131 
132  void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update);
133  void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
134  const RecordData &R, unsigned &I);
135  void MergeDefinitionData(CXXRecordDecl *D,
136  struct CXXRecordDecl::DefinitionData &&NewDD);
137 
138  static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
139  DeclContext *DC,
140  unsigned Index);
141  static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
142  unsigned Index, NamedDecl *D);
143 
144  /// Results from loading a RedeclarableDecl.
145  class RedeclarableResult {
146  GlobalDeclID FirstID;
147  Decl *MergeWith;
148  bool IsKeyDecl;
149 
150  public:
151  RedeclarableResult(GlobalDeclID FirstID, Decl *MergeWith, bool IsKeyDecl)
152  : FirstID(FirstID), MergeWith(MergeWith), IsKeyDecl(IsKeyDecl) {}
153 
154  /// \brief Retrieve the first ID.
155  GlobalDeclID getFirstID() const { return FirstID; }
156 
157  /// \brief Is this declaration a key declaration?
158  bool isKeyDecl() const { return IsKeyDecl; }
159 
160  /// \brief Get a known declaration that this should be merged with, if
161  /// any.
162  Decl *getKnownMergeTarget() const { return MergeWith; }
163  };
164 
165  /// \brief Class used to capture the result of searching for an existing
166  /// declaration of a specific kind and name, along with the ability
167  /// to update the place where this result was found (the declaration
168  /// chain hanging off an identifier or the DeclContext we searched in)
169  /// if requested.
170  class FindExistingResult {
171  ASTReader &Reader;
172  NamedDecl *New;
173  NamedDecl *Existing;
174  mutable bool AddResult;
175 
176  unsigned AnonymousDeclNumber;
177  IdentifierInfo *TypedefNameForLinkage;
178 
179  void operator=(FindExistingResult&) = delete;
180 
181  public:
182  FindExistingResult(ASTReader &Reader)
183  : Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
184  AnonymousDeclNumber(0), TypedefNameForLinkage(nullptr) {}
185 
186  FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
187  unsigned AnonymousDeclNumber,
188  IdentifierInfo *TypedefNameForLinkage)
189  : Reader(Reader), New(New), Existing(Existing), AddResult(true),
190  AnonymousDeclNumber(AnonymousDeclNumber),
191  TypedefNameForLinkage(TypedefNameForLinkage) {}
192 
193  FindExistingResult(const FindExistingResult &Other)
194  : Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
195  AddResult(Other.AddResult),
196  AnonymousDeclNumber(Other.AnonymousDeclNumber),
197  TypedefNameForLinkage(Other.TypedefNameForLinkage) {
198  Other.AddResult = false;
199  }
200 
201  ~FindExistingResult();
202 
203  /// \brief Suppress the addition of this result into the known set of
204  /// names.
205  void suppress() { AddResult = false; }
206 
207  operator NamedDecl*() const { return Existing; }
208 
209  template<typename T>
210  operator T*() const { return dyn_cast_or_null<T>(Existing); }
211  };
212 
213  static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
214  DeclContext *DC);
215  FindExistingResult findExisting(NamedDecl *D);
216 
217  public:
218  ASTDeclReader(ASTReader &Reader, ASTReader::RecordLocation Loc,
219  DeclID thisDeclID, SourceLocation ThisDeclLoc,
220  const RecordData &Record, unsigned &Idx)
221  : Reader(Reader), F(*Loc.F), Offset(Loc.Offset), ThisDeclID(thisDeclID),
222  ThisDeclLoc(ThisDeclLoc), Record(Record), Idx(Idx),
223  TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
224  TypedefNameForLinkage(nullptr), HasPendingBody(false),
225  IsDeclMarkedUsed(false) {}
226 
227  template <typename DeclT>
228  static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
229  static Decl *getMostRecentDeclImpl(...);
230  static Decl *getMostRecentDecl(Decl *D);
231 
232  template <typename DeclT>
233  static void attachPreviousDeclImpl(ASTReader &Reader,
235  Decl *Canon);
236  static void attachPreviousDeclImpl(ASTReader &Reader, ...);
237  static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
238  Decl *Canon);
239 
240  template <typename DeclT>
241  static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
242  static void attachLatestDeclImpl(...);
243  static void attachLatestDecl(Decl *D, Decl *latest);
244 
245  template <typename DeclT>
246  static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
247  static void markIncompleteDeclChainImpl(...);
248 
249  /// \brief Determine whether this declaration has a pending body.
250  bool hasPendingBody() const { return HasPendingBody; }
251 
252  void Visit(Decl *D);
253 
254  void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
255  const RecordData &Record);
256 
259  Cat->NextClassCategory = Next;
260  }
261 
262  void VisitDecl(Decl *D);
263  void VisitPragmaCommentDecl(PragmaCommentDecl *D);
264  void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
265  void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
266  void VisitNamedDecl(NamedDecl *ND);
267  void VisitLabelDecl(LabelDecl *LD);
268  void VisitNamespaceDecl(NamespaceDecl *D);
269  void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
270  void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
271  void VisitTypeDecl(TypeDecl *TD);
272  RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
273  void VisitTypedefDecl(TypedefDecl *TD);
274  void VisitTypeAliasDecl(TypeAliasDecl *TD);
275  void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
276  RedeclarableResult VisitTagDecl(TagDecl *TD);
277  void VisitEnumDecl(EnumDecl *ED);
278  RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
279  void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
280  RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
281  void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
282  RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
286  VisitClassTemplateSpecializationDeclImpl(D);
287  }
288  void VisitClassTemplatePartialSpecializationDecl(
290  void VisitClassScopeFunctionSpecializationDecl(
292  RedeclarableResult
293  VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
295  VisitVarTemplateSpecializationDeclImpl(D);
296  }
297  void VisitVarTemplatePartialSpecializationDecl(
299  void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
300  void VisitValueDecl(ValueDecl *VD);
301  void VisitEnumConstantDecl(EnumConstantDecl *ECD);
302  void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
303  void VisitDeclaratorDecl(DeclaratorDecl *DD);
304  void VisitFunctionDecl(FunctionDecl *FD);
305  void VisitCXXMethodDecl(CXXMethodDecl *D);
306  void VisitCXXConstructorDecl(CXXConstructorDecl *D);
307  void VisitCXXDestructorDecl(CXXDestructorDecl *D);
308  void VisitCXXConversionDecl(CXXConversionDecl *D);
309  void VisitFieldDecl(FieldDecl *FD);
310  void VisitMSPropertyDecl(MSPropertyDecl *FD);
311  void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
312  RedeclarableResult VisitVarDeclImpl(VarDecl *D);
313  void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
314  void VisitImplicitParamDecl(ImplicitParamDecl *PD);
315  void VisitParmVarDecl(ParmVarDecl *PD);
316  void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
317  DeclID VisitTemplateDecl(TemplateDecl *D);
318  RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
319  void VisitClassTemplateDecl(ClassTemplateDecl *D);
320  void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
321  void VisitVarTemplateDecl(VarTemplateDecl *D);
322  void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
323  void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
324  void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
325  void VisitUsingDecl(UsingDecl *D);
326  void VisitUsingShadowDecl(UsingShadowDecl *D);
327  void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
328  void VisitLinkageSpecDecl(LinkageSpecDecl *D);
329  void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
330  void VisitImportDecl(ImportDecl *D);
331  void VisitAccessSpecDecl(AccessSpecDecl *D);
332  void VisitFriendDecl(FriendDecl *D);
333  void VisitFriendTemplateDecl(FriendTemplateDecl *D);
334  void VisitStaticAssertDecl(StaticAssertDecl *D);
335  void VisitBlockDecl(BlockDecl *BD);
336  void VisitCapturedDecl(CapturedDecl *CD);
337  void VisitEmptyDecl(EmptyDecl *D);
338 
339  std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
340 
341  template<typename T>
342  RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
343 
344  template<typename T>
345  void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
346  DeclID TemplatePatternID = 0);
347 
348  template<typename T>
349  void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
350  RedeclarableResult &Redecl,
351  DeclID TemplatePatternID = 0);
352 
353  template<typename T>
354  void mergeMergeable(Mergeable<T> *D);
355 
356  void mergeTemplatePattern(RedeclarableTemplateDecl *D,
357  RedeclarableTemplateDecl *Existing,
358  DeclID DsID, bool IsKeyDecl);
359 
360  ObjCTypeParamList *ReadObjCTypeParamList();
361 
362  // FIXME: Reorder according to DeclNodes.td?
363  void VisitObjCMethodDecl(ObjCMethodDecl *D);
364  void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
365  void VisitObjCContainerDecl(ObjCContainerDecl *D);
366  void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
367  void VisitObjCIvarDecl(ObjCIvarDecl *D);
368  void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
369  void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
370  void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
371  void VisitObjCImplDecl(ObjCImplDecl *D);
372  void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
373  void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
374  void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
375  void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
376  void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
377  void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
378  void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
379  void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
380 
381  /// We've merged the definition \p MergedDef into the existing definition
382  /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
383  /// visible.
385  if (Def->isHidden()) {
386  // If MergedDef is visible or becomes visible, make the definition visible.
387  if (!MergedDef->isHidden())
388  Def->Hidden = false;
389  else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
391  Def, MergedDef->getImportedOwningModule(),
392  /*NotifyListeners*/ false);
393  Reader.PendingMergedDefinitionsToDeduplicate.insert(Def);
394  } else {
395  auto SubmoduleID = MergedDef->getOwningModuleID();
396  assert(SubmoduleID && "hidden definition in no module");
397  Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back(Def);
398  }
399  }
400  }
401  };
402 } // end namespace clang
403 
404 namespace {
405 /// Iterator over the redeclarations of a declaration that have already
406 /// been merged into the same redeclaration chain.
407 template<typename DeclT>
408 class MergedRedeclIterator {
409  DeclT *Start, *Canonical, *Current;
410 public:
411  MergedRedeclIterator() : Current(nullptr) {}
412  MergedRedeclIterator(DeclT *Start)
413  : Start(Start), Canonical(nullptr), Current(Start) {}
414 
415  DeclT *operator*() { return Current; }
416 
417  MergedRedeclIterator &operator++() {
418  if (Current->isFirstDecl()) {
419  Canonical = Current;
420  Current = Current->getMostRecentDecl();
421  } else
422  Current = Current->getPreviousDecl();
423 
424  // If we started in the merged portion, we'll reach our start position
425  // eventually. Otherwise, we'll never reach it, but the second declaration
426  // we reached was the canonical declaration, so stop when we see that one
427  // again.
428  if (Current == Start || Current == Canonical)
429  Current = nullptr;
430  return *this;
431  }
432 
433  friend bool operator!=(const MergedRedeclIterator &A,
434  const MergedRedeclIterator &B) {
435  return A.Current != B.Current;
436  }
437 };
438 } // end anonymous namespace
439 
440 template<typename DeclT>
441 llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
442  return llvm::make_range(MergedRedeclIterator<DeclT>(D),
443  MergedRedeclIterator<DeclT>());
444 }
445 
446 uint64_t ASTDeclReader::GetCurrentCursorOffset() {
447  return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
448 }
449 
452 
453  // At this point we have deserialized and merged the decl and it is safe to
454  // update its canonical decl to signal that the entire entity is used.
455  D->getCanonicalDecl()->Used |= IsDeclMarkedUsed;
456  IsDeclMarkedUsed = false;
457 
458  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
459  if (DD->DeclInfo) {
461  DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
462  Info->TInfo =
463  GetTypeSourceInfo(Record, Idx);
464  }
465  else {
466  DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
467  }
468  }
469 
470  if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
471  // We have a fully initialized TypeDecl. Read its type now.
472  TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
473 
474  // If this is a tag declaration with a typedef name for linkage, it's safe
475  // to load that typedef now.
476  if (NamedDeclForTagDecl)
477  cast<TagDecl>(D)->TypedefNameDeclOrQualifier =
478  cast<TypedefNameDecl>(Reader.GetDecl(NamedDeclForTagDecl));
479  } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
480  // if we have a fully initialized TypeDecl, we can safely read its type now.
481  ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
482  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
483  // FunctionDecl's body was written last after all other Stmts/Exprs.
484  // We only read it if FD doesn't already have a body (e.g., from another
485  // module).
486  // FIXME: Can we diagnose ODR violations somehow?
487  if (Record[Idx++]) {
488  if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
489  CD->NumCtorInitializers = Record[Idx++];
490  if (CD->NumCtorInitializers)
491  CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
492  }
493  Reader.PendingBodies[FD] = GetCurrentCursorOffset();
494  HasPendingBody = true;
495  }
496  }
497 }
498 
500  if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
501  isa<ParmVarDecl>(D)) {
502  // We don't want to deserialize the DeclContext of a template
503  // parameter or of a parameter of a function template immediately. These
504  // entities might be used in the formulation of its DeclContext (for
505  // example, a function parameter can be used in decltype() in trailing
506  // return type of the function). Use the translation unit DeclContext as a
507  // placeholder.
508  GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
509  GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
510  if (!LexicalDCIDForTemplateParmDecl)
511  LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;
512  Reader.addPendingDeclContextInfo(D,
513  SemaDCIDForTemplateParmDecl,
514  LexicalDCIDForTemplateParmDecl);
515  D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
516  } else {
517  DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
518  DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
519  if (!LexicalDC)
520  LexicalDC = SemaDC;
521  DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
522  // Avoid calling setLexicalDeclContext() directly because it uses
523  // Decl::getASTContext() internally which is unsafe during derialization.
524  D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
525  Reader.getContext());
526  }
527  D->setLocation(ThisDeclLoc);
528  D->setInvalidDecl(Record[Idx++]);
529  if (Record[Idx++]) { // hasAttrs
530  AttrVec Attrs;
531  Reader.ReadAttributes(F, Attrs, Record, Idx);
532  // Avoid calling setAttrs() directly because it uses Decl::getASTContext()
533  // internally which is unsafe during derialization.
534  D->setAttrsImpl(Attrs, Reader.getContext());
535  }
536  D->setImplicit(Record[Idx++]);
537  D->Used = Record[Idx++];
538  IsDeclMarkedUsed |= D->Used;
539  D->setReferenced(Record[Idx++]);
540  D->setTopLevelDeclInObjCContainer(Record[Idx++]);
541  D->setAccess((AccessSpecifier)Record[Idx++]);
542  D->FromASTFile = true;
543  D->setModulePrivate(Record[Idx++]);
544  D->Hidden = D->isModulePrivate();
545 
546  // Determine whether this declaration is part of a (sub)module. If so, it
547  // may not yet be visible.
548  if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
549  // Store the owning submodule ID in the declaration.
550  D->setOwningModuleID(SubmoduleID);
551 
552  if (D->Hidden) {
553  // Module-private declarations are never visible, so there is no work to do.
554  } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
555  // If local visibility is being tracked, this declaration will become
556  // hidden and visible as the owning module does. Inform Sema that this
557  // declaration might not be visible.
558  D->Hidden = true;
559  } else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
560  if (Owner->NameVisibility != Module::AllVisible) {
561  // The owning module is not visible. Mark this declaration as hidden.
562  D->Hidden = true;
563 
564  // Note that this declaration was hidden because its owning module is
565  // not yet visible.
566  Reader.HiddenNamesMap[Owner].push_back(D);
567  }
568  }
569  }
570 }
571 
573  VisitDecl(D);
574  D->setLocation(ReadSourceLocation(Record, Idx));
575  D->CommentKind = (PragmaMSCommentKind)Record[Idx++];
576  std::string Arg = ReadString(Record, Idx);
577  memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
578  D->getTrailingObjects<char>()[Arg.size()] = '\0';
579 }
580 
582  VisitDecl(D);
583  D->setLocation(ReadSourceLocation(Record, Idx));
584  std::string Name = ReadString(Record, Idx);
585  memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());
586  D->getTrailingObjects<char>()[Name.size()] = '\0';
587 
588  D->ValueStart = Name.size() + 1;
589  std::string Value = ReadString(Record, Idx);
590  memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
591  Value.size());
592  D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
593 }
594 
596  llvm_unreachable("Translation units are not serialized");
597 }
598 
600  VisitDecl(ND);
601  ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
602  AnonymousDeclNumber = Record[Idx++];
603 }
604 
606  VisitNamedDecl(TD);
607  TD->setLocStart(ReadSourceLocation(Record, Idx));
608  // Delay type reading until after we have fully initialized the decl.
609  TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
610 }
611 
612 ASTDeclReader::RedeclarableResult
614  RedeclarableResult Redecl = VisitRedeclarable(TD);
615  VisitTypeDecl(TD);
616  TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
617  if (Record[Idx++]) { // isModed
618  QualType modedT = Reader.readType(F, Record, Idx);
619  TD->setModedTypeSourceInfo(TInfo, modedT);
620  } else
621  TD->setTypeSourceInfo(TInfo);
622  return Redecl;
623 }
624 
626  RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
627  mergeRedeclarable(TD, Redecl);
628 }
629 
631  RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
632  if (auto *Template = ReadDeclAs<TypeAliasTemplateDecl>(Record, Idx))
633  // Merged when we merge the template.
634  TD->setDescribedAliasTemplate(Template);
635  else
636  mergeRedeclarable(TD, Redecl);
637 }
638 
639 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
640  RedeclarableResult Redecl = VisitRedeclarable(TD);
641  VisitTypeDecl(TD);
642 
643  TD->IdentifierNamespace = Record[Idx++];
644  TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
645  if (!isa<CXXRecordDecl>(TD))
646  TD->setCompleteDefinition(Record[Idx++]);
647  TD->setEmbeddedInDeclarator(Record[Idx++]);
648  TD->setFreeStanding(Record[Idx++]);
649  TD->setCompleteDefinitionRequired(Record[Idx++]);
650  TD->setBraceRange(ReadSourceRange(Record, Idx));
651 
652  switch (Record[Idx++]) {
653  case 0:
654  break;
655  case 1: { // ExtInfo
656  TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
657  ReadQualifierInfo(*Info, Record, Idx);
658  TD->TypedefNameDeclOrQualifier = Info;
659  break;
660  }
661  case 2: // TypedefNameForAnonDecl
662  NamedDeclForTagDecl = ReadDeclID(Record, Idx);
663  TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
664  break;
665  default:
666  llvm_unreachable("unexpected tag info kind");
667  }
668 
669  if (!isa<CXXRecordDecl>(TD))
670  mergeRedeclarable(TD, Redecl);
671  return Redecl;
672 }
673 
675  VisitTagDecl(ED);
676  if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
677  ED->setIntegerTypeSourceInfo(TI);
678  else
679  ED->setIntegerType(Reader.readType(F, Record, Idx));
680  ED->setPromotionType(Reader.readType(F, Record, Idx));
681  ED->setNumPositiveBits(Record[Idx++]);
682  ED->setNumNegativeBits(Record[Idx++]);
683  ED->IsScoped = Record[Idx++];
684  ED->IsScopedUsingClassTag = Record[Idx++];
685  ED->IsFixed = Record[Idx++];
686 
687  // If this is a definition subject to the ODR, and we already have a
688  // definition, merge this one into it.
689  if (ED->IsCompleteDefinition &&
690  Reader.getContext().getLangOpts().Modules &&
691  Reader.getContext().getLangOpts().CPlusPlus) {
692  EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
693  if (!OldDef) {
694  // This is the first time we've seen an imported definition. Look for a
695  // local definition before deciding that we are the first definition.
696  for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
697  if (!D->isFromASTFile() && D->isCompleteDefinition()) {
698  OldDef = D;
699  break;
700  }
701  }
702  }
703  if (OldDef) {
704  Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
705  ED->IsCompleteDefinition = false;
706  mergeDefinitionVisibility(OldDef, ED);
707  } else {
708  OldDef = ED;
709  }
710  }
711 
712  if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
714  SourceLocation POI = ReadSourceLocation(Record, Idx);
715  ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
717  }
718 }
719 
720 ASTDeclReader::RedeclarableResult
722  RedeclarableResult Redecl = VisitTagDecl(RD);
723  RD->setHasFlexibleArrayMember(Record[Idx++]);
724  RD->setAnonymousStructOrUnion(Record[Idx++]);
725  RD->setHasObjectMember(Record[Idx++]);
726  RD->setHasVolatileMember(Record[Idx++]);
727  return Redecl;
728 }
729 
731  VisitNamedDecl(VD);
732  VD->setType(Reader.readType(F, Record, Idx));
733 }
734 
736  VisitValueDecl(ECD);
737  if (Record[Idx++])
738  ECD->setInitExpr(Reader.ReadExpr(F));
739  ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
740  mergeMergeable(ECD);
741 }
742 
744  VisitValueDecl(DD);
745  DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
746  if (Record[Idx++]) { // hasExtInfo
748  = new (Reader.getContext()) DeclaratorDecl::ExtInfo();
749  ReadQualifierInfo(*Info, Record, Idx);
750  DD->DeclInfo = Info;
751  }
752 }
753 
755  RedeclarableResult Redecl = VisitRedeclarable(FD);
756  VisitDeclaratorDecl(FD);
757 
758  ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
759  FD->IdentifierNamespace = Record[Idx++];
760 
761  // FunctionDecl's body is handled last at ASTDeclReader::Visit,
762  // after everything else is read.
763 
764  FD->SClass = (StorageClass)Record[Idx++];
765  FD->IsInline = Record[Idx++];
766  FD->IsInlineSpecified = Record[Idx++];
767  FD->IsVirtualAsWritten = Record[Idx++];
768  FD->IsPure = Record[Idx++];
769  FD->HasInheritedPrototype = Record[Idx++];
770  FD->HasWrittenPrototype = Record[Idx++];
771  FD->IsDeleted = Record[Idx++];
772  FD->IsTrivial = Record[Idx++];
773  FD->IsDefaulted = Record[Idx++];
774  FD->IsExplicitlyDefaulted = Record[Idx++];
775  FD->HasImplicitReturnZero = Record[Idx++];
776  FD->IsConstexpr = Record[Idx++];
777  FD->HasSkippedBody = Record[Idx++];
778  FD->IsLateTemplateParsed = Record[Idx++];
779  FD->setCachedLinkage(Linkage(Record[Idx++]));
780  FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
781 
782  switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
784  mergeRedeclarable(FD, Redecl);
785  break;
787  // Merged when we merge the template.
788  FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
789  Idx));
790  break;
792  FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
794  SourceLocation POI = ReadSourceLocation(Record, Idx);
795  FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
797  mergeRedeclarable(FD, Redecl);
798  break;
799  }
801  FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
802  Idx);
804 
805  // Template arguments.
807  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
808  /*Canonicalize*/ true);
809 
810  // Template args as written.
812  SourceLocation LAngleLoc, RAngleLoc;
813  bool HasTemplateArgumentsAsWritten = Record[Idx++];
814  if (HasTemplateArgumentsAsWritten) {
815  unsigned NumTemplateArgLocs = Record[Idx++];
816  TemplArgLocs.reserve(NumTemplateArgLocs);
817  for (unsigned i=0; i != NumTemplateArgLocs; ++i)
818  TemplArgLocs.push_back(
819  Reader.ReadTemplateArgumentLoc(F, Record, Idx));
820 
821  LAngleLoc = ReadSourceLocation(Record, Idx);
822  RAngleLoc = ReadSourceLocation(Record, Idx);
823  }
824 
825  SourceLocation POI = ReadSourceLocation(Record, Idx);
826 
827  ASTContext &C = Reader.getContext();
828  TemplateArgumentList *TemplArgList
829  = TemplateArgumentList::CreateCopy(C, TemplArgs);
830  TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
831  for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
832  TemplArgsInfo.addArgument(TemplArgLocs[i]);
834  = FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
835  TemplArgList,
836  HasTemplateArgumentsAsWritten ? &TemplArgsInfo
837  : nullptr,
838  POI);
839  FD->TemplateOrSpecialization = FTInfo;
840 
841  if (FD->isCanonicalDecl()) { // if canonical add to template's set.
842  // The template that contains the specializations set. It's not safe to
843  // use getCanonicalDecl on Template since it may still be initializing.
844  FunctionTemplateDecl *CanonTemplate
845  = ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
846  // Get the InsertPos by FindNodeOrInsertPos() instead of calling
847  // InsertNode(FTInfo) directly to avoid the getASTContext() call in
848  // FunctionTemplateSpecializationInfo's Profile().
849  // We avoid getASTContext because a decl in the parent hierarchy may
850  // be initializing.
851  llvm::FoldingSetNodeID ID;
853  void *InsertPos = nullptr;
854  FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
855  FunctionTemplateSpecializationInfo *ExistingInfo =
856  CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
857  if (InsertPos)
858  CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
859  else {
860  assert(Reader.getContext().getLangOpts().Modules &&
861  "already deserialized this template specialization");
862  mergeRedeclarable(FD, ExistingInfo->Function, Redecl);
863  }
864  }
865  break;
866  }
868  // Templates.
869  UnresolvedSet<8> TemplDecls;
870  unsigned NumTemplates = Record[Idx++];
871  while (NumTemplates--)
872  TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
873 
874  // Templates args.
875  TemplateArgumentListInfo TemplArgs;
876  unsigned NumArgs = Record[Idx++];
877  while (NumArgs--)
878  TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
879  TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
880  TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
881 
882  FD->setDependentTemplateSpecialization(Reader.getContext(),
883  TemplDecls, TemplArgs);
884  // These are not merged; we don't need to merge redeclarations of dependent
885  // template friends.
886  break;
887  }
888  }
889 
890  // Read in the parameters.
891  unsigned NumParams = Record[Idx++];
893  Params.reserve(NumParams);
894  for (unsigned I = 0; I != NumParams; ++I)
895  Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
896  FD->setParams(Reader.getContext(), Params);
897 }
898 
900  VisitNamedDecl(MD);
901  if (Record[Idx++]) {
902  // Load the body on-demand. Most clients won't care, because method
903  // definitions rarely show up in headers.
904  Reader.PendingBodies[MD] = GetCurrentCursorOffset();
905  HasPendingBody = true;
906  MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
907  MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
908  }
909  MD->setInstanceMethod(Record[Idx++]);
910  MD->setVariadic(Record[Idx++]);
911  MD->setPropertyAccessor(Record[Idx++]);
912  MD->setDefined(Record[Idx++]);
913  MD->IsOverriding = Record[Idx++];
914  MD->HasSkippedBody = Record[Idx++];
915 
916  MD->IsRedeclaration = Record[Idx++];
917  MD->HasRedeclaration = Record[Idx++];
918  if (MD->HasRedeclaration)
919  Reader.getContext().setObjCMethodRedeclaration(MD,
920  ReadDeclAs<ObjCMethodDecl>(Record, Idx));
921 
923  MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
924  MD->SetRelatedResultType(Record[Idx++]);
925  MD->setReturnType(Reader.readType(F, Record, Idx));
926  MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
927  MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
928  unsigned NumParams = Record[Idx++];
930  Params.reserve(NumParams);
931  for (unsigned I = 0; I != NumParams; ++I)
932  Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
933 
934  MD->SelLocsKind = Record[Idx++];
935  unsigned NumStoredSelLocs = Record[Idx++];
937  SelLocs.reserve(NumStoredSelLocs);
938  for (unsigned i = 0; i != NumStoredSelLocs; ++i)
939  SelLocs.push_back(ReadSourceLocation(Record, Idx));
940 
941  MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
942 }
943 
945  VisitTypedefNameDecl(D);
946 
947  D->Variance = Record[Idx++];
948  D->Index = Record[Idx++];
949  D->VarianceLoc = ReadSourceLocation(Record, Idx);
950  D->ColonLoc = ReadSourceLocation(Record, Idx);
951 }
952 
954  VisitNamedDecl(CD);
955  CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
956  CD->setAtEndRange(ReadSourceRange(Record, Idx));
957 }
958 
960  unsigned numParams = Record[Idx++];
961  if (numParams == 0)
962  return nullptr;
963 
965  typeParams.reserve(numParams);
966  for (unsigned i = 0; i != numParams; ++i) {
967  auto typeParam = ReadDeclAs<ObjCTypeParamDecl>(Record, Idx);
968  if (!typeParam)
969  return nullptr;
970 
971  typeParams.push_back(typeParam);
972  }
973 
974  SourceLocation lAngleLoc = ReadSourceLocation(Record, Idx);
975  SourceLocation rAngleLoc = ReadSourceLocation(Record, Idx);
976 
977  return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
978  typeParams, rAngleLoc);
979 }
980 
982  RedeclarableResult Redecl = VisitRedeclarable(ID);
983  VisitObjCContainerDecl(ID);
984  TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
985  mergeRedeclarable(ID, Redecl);
986 
987  ID->TypeParamList = ReadObjCTypeParamList();
988  if (Record[Idx++]) {
989  // Read the definition.
990  ID->allocateDefinitionData();
991 
992  // Set the definition data of the canonical declaration, so other
993  // redeclarations will see it.
994  ID->getCanonicalDecl()->Data = ID->Data;
995 
996  ObjCInterfaceDecl::DefinitionData &Data = ID->data();
997 
998  // Read the superclass.
999  Data.SuperClassTInfo = GetTypeSourceInfo(Record, Idx);
1000 
1001  Data.EndLoc = ReadSourceLocation(Record, Idx);
1002  Data.HasDesignatedInitializers = Record[Idx++];
1003 
1004  // Read the directly referenced protocols and their SourceLocations.
1005  unsigned NumProtocols = Record[Idx++];
1007  Protocols.reserve(NumProtocols);
1008  for (unsigned I = 0; I != NumProtocols; ++I)
1009  Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1011  ProtoLocs.reserve(NumProtocols);
1012  for (unsigned I = 0; I != NumProtocols; ++I)
1013  ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1014  ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
1015  Reader.getContext());
1016 
1017  // Read the transitive closure of protocols referenced by this class.
1018  NumProtocols = Record[Idx++];
1019  Protocols.clear();
1020  Protocols.reserve(NumProtocols);
1021  for (unsigned I = 0; I != NumProtocols; ++I)
1022  Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1023  ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
1024  Reader.getContext());
1025 
1026  // We will rebuild this list lazily.
1027  ID->setIvarList(nullptr);
1028 
1029  // Note that we have deserialized a definition.
1030  Reader.PendingDefinitions.insert(ID);
1031 
1032  // Note that we've loaded this Objective-C class.
1033  Reader.ObjCClassesLoaded.push_back(ID);
1034  } else {
1035  ID->Data = ID->getCanonicalDecl()->Data;
1036  }
1037 }
1038 
1040  VisitFieldDecl(IVD);
1041  IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
1042  // This field will be built lazily.
1043  IVD->setNextIvar(nullptr);
1044  bool synth = Record[Idx++];
1045  IVD->setSynthesize(synth);
1046 }
1047 
1049  RedeclarableResult Redecl = VisitRedeclarable(PD);
1050  VisitObjCContainerDecl(PD);
1051  mergeRedeclarable(PD, Redecl);
1052 
1053  if (Record[Idx++]) {
1054  // Read the definition.
1055  PD->allocateDefinitionData();
1056 
1057  // Set the definition data of the canonical declaration, so other
1058  // redeclarations will see it.
1059  PD->getCanonicalDecl()->Data = PD->Data;
1060 
1061  unsigned NumProtoRefs = Record[Idx++];
1063  ProtoRefs.reserve(NumProtoRefs);
1064  for (unsigned I = 0; I != NumProtoRefs; ++I)
1065  ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1067  ProtoLocs.reserve(NumProtoRefs);
1068  for (unsigned I = 0; I != NumProtoRefs; ++I)
1069  ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1070  PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
1071  Reader.getContext());
1072 
1073  // Note that we have deserialized a definition.
1074  Reader.PendingDefinitions.insert(PD);
1075  } else {
1076  PD->Data = PD->getCanonicalDecl()->Data;
1077  }
1078 }
1079 
1081  VisitFieldDecl(FD);
1082 }
1083 
1085  VisitObjCContainerDecl(CD);
1086  CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
1087  CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
1088  CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
1089 
1090  // Note that this category has been deserialized. We do this before
1091  // deserializing the interface declaration, so that it will consider this
1092  /// category.
1093  Reader.CategoriesDeserialized.insert(CD);
1094 
1095  CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
1096  CD->TypeParamList = ReadObjCTypeParamList();
1097  unsigned NumProtoRefs = Record[Idx++];
1099  ProtoRefs.reserve(NumProtoRefs);
1100  for (unsigned I = 0; I != NumProtoRefs; ++I)
1101  ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
1103  ProtoLocs.reserve(NumProtoRefs);
1104  for (unsigned I = 0; I != NumProtoRefs; ++I)
1105  ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
1106  CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
1107  Reader.getContext());
1108 }
1109 
1111  VisitNamedDecl(CAD);
1112  CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1113 }
1114 
1116  VisitNamedDecl(D);
1117  D->setAtLoc(ReadSourceLocation(Record, Idx));
1118  D->setLParenLoc(ReadSourceLocation(Record, Idx));
1119  QualType T = Reader.readType(F, Record, Idx);
1120  TypeSourceInfo *TSI = GetTypeSourceInfo(Record, Idx);
1121  D->setType(T, TSI);
1127  (ObjCPropertyDecl::PropertyControl)Record[Idx++]);
1128  D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
1129  D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
1130  D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1131  D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
1132  D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
1133 }
1134 
1136  VisitObjCContainerDecl(D);
1137  D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1138 }
1139 
1141  VisitObjCImplDecl(D);
1142  D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
1143  D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
1144 }
1145 
1147  VisitObjCImplDecl(D);
1148  D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
1149  D->SuperLoc = ReadSourceLocation(Record, Idx);
1150  D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
1151  D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
1152  D->setHasNonZeroConstructors(Record[Idx++]);
1153  D->setHasDestructors(Record[Idx++]);
1154  D->NumIvarInitializers = Record[Idx++];
1155  if (D->NumIvarInitializers)
1156  D->IvarInitializers = ReadGlobalOffset(F, Record, Idx);
1157 }
1158 
1160  VisitDecl(D);
1161  D->setAtLoc(ReadSourceLocation(Record, Idx));
1162  D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
1163  D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
1164  D->IvarLoc = ReadSourceLocation(Record, Idx);
1165  D->setGetterCXXConstructor(Reader.ReadExpr(F));
1166  D->setSetterCXXAssignment(Reader.ReadExpr(F));
1167 }
1168 
1170  VisitDeclaratorDecl(FD);
1171  FD->Mutable = Record[Idx++];
1172  if (int BitWidthOrInitializer = Record[Idx++]) {
1173  FD->InitStorage.setInt(
1174  static_cast<FieldDecl::InitStorageKind>(BitWidthOrInitializer - 1));
1175  if (FD->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
1176  // Read captured variable length array.
1177  FD->InitStorage.setPointer(
1178  Reader.readType(F, Record, Idx).getAsOpaquePtr());
1179  } else {
1180  FD->InitStorage.setPointer(Reader.ReadExpr(F));
1181  }
1182  }
1183  if (!FD->getDeclName()) {
1184  if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
1185  Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
1186  }
1187  mergeMergeable(FD);
1188 }
1189 
1191  VisitDeclaratorDecl(PD);
1192  PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1193  PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
1194 }
1195 
1197  VisitValueDecl(FD);
1198 
1199  FD->ChainingSize = Record[Idx++];
1200  assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
1201  FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
1202 
1203  for (unsigned I = 0; I != FD->ChainingSize; ++I)
1204  FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
1205 
1206  mergeMergeable(FD);
1207 }
1208 
1209 ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
1210  RedeclarableResult Redecl = VisitRedeclarable(VD);
1211  VisitDeclaratorDecl(VD);
1212 
1213  VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
1214  VD->VarDeclBits.TSCSpec = Record[Idx++];
1215  VD->VarDeclBits.InitStyle = Record[Idx++];
1216  if (!isa<ParmVarDecl>(VD)) {
1217  VD->NonParmVarDeclBits.ExceptionVar = Record[Idx++];
1218  VD->NonParmVarDeclBits.NRVOVariable = Record[Idx++];
1219  VD->NonParmVarDeclBits.CXXForRangeDecl = Record[Idx++];
1220  VD->NonParmVarDeclBits.ARCPseudoStrong = Record[Idx++];
1221  VD->NonParmVarDeclBits.IsInline = Record[Idx++];
1222  VD->NonParmVarDeclBits.IsInlineSpecified = Record[Idx++];
1223  VD->NonParmVarDeclBits.IsConstexpr = Record[Idx++];
1224  VD->NonParmVarDeclBits.IsInitCapture = Record[Idx++];
1225  VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
1226  }
1227  Linkage VarLinkage = Linkage(Record[Idx++]);
1228  VD->setCachedLinkage(VarLinkage);
1229 
1230  // Reconstruct the one piece of the IdentifierNamespace that we need.
1231  if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
1232  VD->getLexicalDeclContext()->isFunctionOrMethod())
1233  VD->setLocalExternDecl();
1234 
1235  if (uint64_t Val = Record[Idx++]) {
1236  VD->setInit(Reader.ReadExpr(F));
1237  if (Val > 1) {
1238  EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
1239  Eval->CheckedICE = true;
1240  Eval->IsICE = Val == 3;
1241  }
1242  }
1243 
1244  enum VarKind {
1245  VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1246  };
1247  switch ((VarKind)Record[Idx++]) {
1248  case VarNotTemplate:
1249  // Only true variables (not parameters or implicit parameters) can be
1250  // merged; the other kinds are not really redeclarable at all.
1251  if (!isa<ParmVarDecl>(VD) && !isa<ImplicitParamDecl>(VD) &&
1252  !isa<VarTemplateSpecializationDecl>(VD))
1253  mergeRedeclarable(VD, Redecl);
1254  break;
1255  case VarTemplate:
1256  // Merged when we merge the template.
1257  VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
1258  break;
1259  case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
1260  VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
1262  SourceLocation POI = ReadSourceLocation(Record, Idx);
1263  Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
1264  mergeRedeclarable(VD, Redecl);
1265  break;
1266  }
1267  }
1268 
1269  return Redecl;
1270 }
1271 
1273  VisitVarDecl(PD);
1274 }
1275 
1277  VisitVarDecl(PD);
1278  unsigned isObjCMethodParam = Record[Idx++];
1279  unsigned scopeDepth = Record[Idx++];
1280  unsigned scopeIndex = Record[Idx++];
1281  unsigned declQualifier = Record[Idx++];
1282  if (isObjCMethodParam) {
1283  assert(scopeDepth == 0);
1284  PD->setObjCMethodScopeInfo(scopeIndex);
1285  PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
1286  } else {
1287  PD->setScopeInfo(scopeDepth, scopeIndex);
1288  }
1289  PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
1290  PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
1291  if (Record[Idx++]) // hasUninstantiatedDefaultArg.
1292  PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
1293 
1294  // FIXME: If this is a redeclaration of a function from another module, handle
1295  // inheritance of default arguments.
1296 }
1297 
1299  VisitDecl(AD);
1300  AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
1301  AD->setRParenLoc(ReadSourceLocation(Record, Idx));
1302 }
1303 
1305  VisitDecl(BD);
1306  BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
1307  BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
1308  unsigned NumParams = Record[Idx++];
1310  Params.reserve(NumParams);
1311  for (unsigned I = 0; I != NumParams; ++I)
1312  Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
1313  BD->setParams(Params);
1314 
1315  BD->setIsVariadic(Record[Idx++]);
1316  BD->setBlockMissingReturnType(Record[Idx++]);
1317  BD->setIsConversionFromLambda(Record[Idx++]);
1318 
1319  bool capturesCXXThis = Record[Idx++];
1320  unsigned numCaptures = Record[Idx++];
1322  captures.reserve(numCaptures);
1323  for (unsigned i = 0; i != numCaptures; ++i) {
1324  VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
1325  unsigned flags = Record[Idx++];
1326  bool byRef = (flags & 1);
1327  bool nested = (flags & 2);
1328  Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
1329 
1330  captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
1331  }
1332  BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
1333 }
1334 
1336  VisitDecl(CD);
1337  unsigned ContextParamPos = Record[Idx++];
1338  CD->setNothrow(Record[Idx++] != 0);
1339  // Body is set by VisitCapturedStmt.
1340  for (unsigned I = 0; I < CD->NumParams; ++I) {
1341  if (I != ContextParamPos)
1342  CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1343  else
1344  CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
1345  }
1346 }
1347 
1349  VisitDecl(D);
1350  D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
1351  D->setExternLoc(ReadSourceLocation(Record, Idx));
1352  D->setRBraceLoc(ReadSourceLocation(Record, Idx));
1353 }
1354 
1356  VisitNamedDecl(D);
1357  D->setLocStart(ReadSourceLocation(Record, Idx));
1358 }
1359 
1361  RedeclarableResult Redecl = VisitRedeclarable(D);
1362  VisitNamedDecl(D);
1363  D->setInline(Record[Idx++]);
1364  D->LocStart = ReadSourceLocation(Record, Idx);
1365  D->RBraceLoc = ReadSourceLocation(Record, Idx);
1366 
1367  // Defer loading the anonymous namespace until we've finished merging
1368  // this namespace; loading it might load a later declaration of the
1369  // same namespace, and we have an invariant that older declarations
1370  // get merged before newer ones try to merge.
1371  GlobalDeclID AnonNamespace = 0;
1372  if (Redecl.getFirstID() == ThisDeclID) {
1373  AnonNamespace = ReadDeclID(Record, Idx);
1374  } else {
1375  // Link this namespace back to the first declaration, which has already
1376  // been deserialized.
1377  D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
1378  }
1379 
1380  mergeRedeclarable(D, Redecl);
1381 
1382  if (AnonNamespace) {
1383  // Each module has its own anonymous namespace, which is disjoint from
1384  // any other module's anonymous namespaces, so don't attach the anonymous
1385  // namespace at all.
1386  NamespaceDecl *Anon = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));
1387  if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule)
1388  D->setAnonymousNamespace(Anon);
1389  }
1390 }
1391 
1393  RedeclarableResult Redecl = VisitRedeclarable(D);
1394  VisitNamedDecl(D);
1395  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1396  D->IdentLoc = ReadSourceLocation(Record, Idx);
1397  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1398  D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
1399  mergeRedeclarable(D, Redecl);
1400 }
1401 
1403  VisitNamedDecl(D);
1404  D->setUsingLoc(ReadSourceLocation(Record, Idx));
1405  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1406  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1407  D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
1408  D->setTypename(Record[Idx++]);
1409  if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
1410  Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
1411  mergeMergeable(D);
1412 }
1413 
1415  RedeclarableResult Redecl = VisitRedeclarable(D);
1416  VisitNamedDecl(D);
1417  D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
1418  D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
1419  UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
1420  if (Pattern)
1421  Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
1422  mergeRedeclarable(D, Redecl);
1423 }
1424 
1427  VisitUsingShadowDecl(D);
1428  D->NominatedBaseClassShadowDecl =
1429  ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1430  D->ConstructedBaseClassShadowDecl =
1431  ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1432  D->IsVirtual = Record[Idx++];
1433 }
1434 
1436  VisitNamedDecl(D);
1437  D->UsingLoc = ReadSourceLocation(Record, Idx);
1438  D->NamespaceLoc = ReadSourceLocation(Record, Idx);
1439  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1440  D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
1441  D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
1442 }
1443 
1445  VisitValueDecl(D);
1446  D->setUsingLoc(ReadSourceLocation(Record, Idx));
1447  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1448  ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
1449  mergeMergeable(D);
1450 }
1451 
1454  VisitTypeDecl(D);
1455  D->TypenameLocation = ReadSourceLocation(Record, Idx);
1456  D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
1457  mergeMergeable(D);
1458 }
1459 
1460 void ASTDeclReader::ReadCXXDefinitionData(
1461  struct CXXRecordDecl::DefinitionData &Data,
1462  const RecordData &Record, unsigned &Idx) {
1463  // Note: the caller has deserialized the IsLambda bit already.
1464  Data.UserDeclaredConstructor = Record[Idx++];
1465  Data.UserDeclaredSpecialMembers = Record[Idx++];
1466  Data.Aggregate = Record[Idx++];
1467  Data.PlainOldData = Record[Idx++];
1468  Data.Empty = Record[Idx++];
1469  Data.Polymorphic = Record[Idx++];
1470  Data.Abstract = Record[Idx++];
1471  Data.IsStandardLayout = Record[Idx++];
1472  Data.HasNoNonEmptyBases = Record[Idx++];
1473  Data.HasPrivateFields = Record[Idx++];
1474  Data.HasProtectedFields = Record[Idx++];
1475  Data.HasPublicFields = Record[Idx++];
1476  Data.HasMutableFields = Record[Idx++];
1477  Data.HasVariantMembers = Record[Idx++];
1478  Data.HasOnlyCMembers = Record[Idx++];
1479  Data.HasInClassInitializer = Record[Idx++];
1480  Data.HasUninitializedReferenceMember = Record[Idx++];
1481  Data.HasUninitializedFields = Record[Idx++];
1482  Data.HasInheritedConstructor = Record[Idx++];
1483  Data.HasInheritedAssignment = Record[Idx++];
1484  Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
1485  Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
1486  Data.NeedOverloadResolutionForDestructor = Record[Idx++];
1487  Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
1488  Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
1489  Data.DefaultedDestructorIsDeleted = Record[Idx++];
1490  Data.HasTrivialSpecialMembers = Record[Idx++];
1491  Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
1492  Data.HasIrrelevantDestructor = Record[Idx++];
1493  Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
1494  Data.HasDefaultedDefaultConstructor = Record[Idx++];
1495  Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
1496  Data.HasConstexprDefaultConstructor = Record[Idx++];
1497  Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
1498  Data.ComputedVisibleConversions = Record[Idx++];
1499  Data.UserProvidedDefaultConstructor = Record[Idx++];
1500  Data.DeclaredSpecialMembers = Record[Idx++];
1501  Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
1502  Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
1503  Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
1504  Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
1505 
1506  Data.NumBases = Record[Idx++];
1507  if (Data.NumBases)
1508  Data.Bases = ReadGlobalOffset(F, Record, Idx);
1509  Data.NumVBases = Record[Idx++];
1510  if (Data.NumVBases)
1511  Data.VBases = ReadGlobalOffset(F, Record, Idx);
1512 
1513  Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
1514  Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
1515  assert(Data.Definition && "Data.Definition should be already set!");
1516  Data.FirstFriend = ReadDeclID(Record, Idx);
1517 
1518  if (Data.IsLambda) {
1519  typedef LambdaCapture Capture;
1520  CXXRecordDecl::LambdaDefinitionData &Lambda
1521  = static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
1522  Lambda.Dependent = Record[Idx++];
1523  Lambda.IsGenericLambda = Record[Idx++];
1524  Lambda.CaptureDefault = Record[Idx++];
1525  Lambda.NumCaptures = Record[Idx++];
1526  Lambda.NumExplicitCaptures = Record[Idx++];
1527  Lambda.ManglingNumber = Record[Idx++];
1528  Lambda.ContextDecl = ReadDecl(Record, Idx);
1529  Lambda.Captures
1530  = (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
1531  Capture *ToCapture = Lambda.Captures;
1532  Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
1533  for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
1534  SourceLocation Loc = ReadSourceLocation(Record, Idx);
1535  bool IsImplicit = Record[Idx++];
1536  LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
1537  switch (Kind) {
1538  case LCK_StarThis:
1539  case LCK_This:
1540  case LCK_VLAType:
1541  *ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
1542  break;
1543  case LCK_ByCopy:
1544  case LCK_ByRef:
1545  VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
1546  SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
1547  *ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
1548  break;
1549  }
1550  }
1551  }
1552 }
1553 
1554 void ASTDeclReader::MergeDefinitionData(
1555  CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
1556  assert(D->DefinitionData &&
1557  "merging class definition into non-definition");
1558  auto &DD = *D->DefinitionData;
1559 
1560  if (DD.Definition != MergeDD.Definition) {
1561  // Track that we merged the definitions.
1562  Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
1563  DD.Definition));
1564  Reader.PendingDefinitions.erase(MergeDD.Definition);
1565  MergeDD.Definition->IsCompleteDefinition = false;
1566  mergeDefinitionVisibility(DD.Definition, MergeDD.Definition);
1567  assert(Reader.Lookups.find(MergeDD.Definition) == Reader.Lookups.end() &&
1568  "already loaded pending lookups for merged definition");
1569  }
1570 
1571  auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);
1572  if (PFDI != Reader.PendingFakeDefinitionData.end() &&
1574  // We faked up this definition data because we found a class for which we'd
1575  // not yet loaded the definition. Replace it with the real thing now.
1576  assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");
1578 
1579  // Don't change which declaration is the definition; that is required
1580  // to be invariant once we select it.
1581  auto *Def = DD.Definition;
1582  DD = std::move(MergeDD);
1583  DD.Definition = Def;
1584  return;
1585  }
1586 
1587  // FIXME: Move this out into a .def file?
1588  bool DetectedOdrViolation = false;
1589 #define OR_FIELD(Field) DD.Field |= MergeDD.Field;
1590 #define MATCH_FIELD(Field) \
1591  DetectedOdrViolation |= DD.Field != MergeDD.Field; \
1592  OR_FIELD(Field)
1593  MATCH_FIELD(UserDeclaredConstructor)
1594  MATCH_FIELD(UserDeclaredSpecialMembers)
1595  MATCH_FIELD(Aggregate)
1596  MATCH_FIELD(PlainOldData)
1597  MATCH_FIELD(Empty)
1598  MATCH_FIELD(Polymorphic)
1599  MATCH_FIELD(Abstract)
1600  MATCH_FIELD(IsStandardLayout)
1601  MATCH_FIELD(HasNoNonEmptyBases)
1602  MATCH_FIELD(HasPrivateFields)
1603  MATCH_FIELD(HasProtectedFields)
1604  MATCH_FIELD(HasPublicFields)
1605  MATCH_FIELD(HasMutableFields)
1606  MATCH_FIELD(HasVariantMembers)
1607  MATCH_FIELD(HasOnlyCMembers)
1608  MATCH_FIELD(HasInClassInitializer)
1609  MATCH_FIELD(HasUninitializedReferenceMember)
1610  MATCH_FIELD(HasUninitializedFields)
1611  MATCH_FIELD(HasInheritedConstructor)
1612  MATCH_FIELD(HasInheritedAssignment)
1613  MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
1614  MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
1615  MATCH_FIELD(NeedOverloadResolutionForDestructor)
1616  MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
1617  MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
1618  MATCH_FIELD(DefaultedDestructorIsDeleted)
1619  OR_FIELD(HasTrivialSpecialMembers)
1620  OR_FIELD(DeclaredNonTrivialSpecialMembers)
1621  MATCH_FIELD(HasIrrelevantDestructor)
1622  OR_FIELD(HasConstexprNonCopyMoveConstructor)
1623  OR_FIELD(HasDefaultedDefaultConstructor)
1624  MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
1625  OR_FIELD(HasConstexprDefaultConstructor)
1626  MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
1627  // ComputedVisibleConversions is handled below.
1628  MATCH_FIELD(UserProvidedDefaultConstructor)
1629  OR_FIELD(DeclaredSpecialMembers)
1630  MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
1631  MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
1632  OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
1633  OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
1634  MATCH_FIELD(IsLambda)
1635 #undef OR_FIELD
1636 #undef MATCH_FIELD
1637 
1638  if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
1639  DetectedOdrViolation = true;
1640  // FIXME: Issue a diagnostic if the base classes don't match when we come
1641  // to lazily load them.
1642 
1643  // FIXME: Issue a diagnostic if the list of conversion functions doesn't
1644  // match when we come to lazily load them.
1645  if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
1646  DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
1647  DD.ComputedVisibleConversions = true;
1648  }
1649 
1650  // FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
1651  // lazily load it.
1652 
1653  if (DD.IsLambda) {
1654  // FIXME: ODR-checking for merging lambdas (this happens, for instance,
1655  // when they occur within the body of a function template specialization).
1656  }
1657 
1658  if (DetectedOdrViolation)
1659  Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
1660 }
1661 
1662 void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) {
1663  struct CXXRecordDecl::DefinitionData *DD;
1664  ASTContext &C = Reader.getContext();
1665 
1666  // Determine whether this is a lambda closure type, so that we can
1667  // allocate the appropriate DefinitionData structure.
1668  bool IsLambda = Record[Idx++];
1669  if (IsLambda)
1670  DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
1671  LCD_None);
1672  else
1673  DD = new (C) struct CXXRecordDecl::DefinitionData(D);
1674 
1675  ReadCXXDefinitionData(*DD, Record, Idx);
1676 
1677  // We might already have a definition for this record. This can happen either
1678  // because we're reading an update record, or because we've already done some
1679  // merging. Either way, just merge into it.
1680  CXXRecordDecl *Canon = D->getCanonicalDecl();
1681  if (Canon->DefinitionData) {
1682  MergeDefinitionData(Canon, std::move(*DD));
1683  D->DefinitionData = Canon->DefinitionData;
1684  return;
1685  }
1686 
1687  // Mark this declaration as being a definition.
1688  D->IsCompleteDefinition = true;
1689  D->DefinitionData = DD;
1690 
1691  // If this is not the first declaration or is an update record, we can have
1692  // other redeclarations already. Make a note that we need to propagate the
1693  // DefinitionData pointer onto them.
1694  if (Update || Canon != D) {
1695  Canon->DefinitionData = D->DefinitionData;
1696  Reader.PendingDefinitions.insert(D);
1697  }
1698 }
1699 
1700 ASTDeclReader::RedeclarableResult
1702  RedeclarableResult Redecl = VisitRecordDeclImpl(D);
1703 
1704  ASTContext &C = Reader.getContext();
1705 
1706  enum CXXRecKind {
1707  CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1708  };
1709  switch ((CXXRecKind)Record[Idx++]) {
1710  case CXXRecNotTemplate:
1711  // Merged when we merge the folding set entry in the primary template.
1712  if (!isa<ClassTemplateSpecializationDecl>(D))
1713  mergeRedeclarable(D, Redecl);
1714  break;
1715  case CXXRecTemplate: {
1716  // Merged when we merge the template.
1717  ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
1718  D->TemplateOrInstantiation = Template;
1719  if (!Template->getTemplatedDecl()) {
1720  // We've not actually loaded the ClassTemplateDecl yet, because we're
1721  // currently being loaded as its pattern. Rely on it to set up our
1722  // TypeForDecl (see VisitClassTemplateDecl).
1723  //
1724  // Beware: we do not yet know our canonical declaration, and may still
1725  // get merged once the surrounding class template has got off the ground.
1726  TypeIDForTypeDecl = 0;
1727  }
1728  break;
1729  }
1730  case CXXRecMemberSpecialization: {
1731  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
1733  SourceLocation POI = ReadSourceLocation(Record, Idx);
1734  MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
1735  MSI->setPointOfInstantiation(POI);
1736  D->TemplateOrInstantiation = MSI;
1737  mergeRedeclarable(D, Redecl);
1738  break;
1739  }
1740  }
1741 
1742  bool WasDefinition = Record[Idx++];
1743  if (WasDefinition)
1744  ReadCXXRecordDefinition(D, /*Update*/false);
1745  else
1746  // Propagate DefinitionData pointer from the canonical declaration.
1747  D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
1748 
1749  // Lazily load the key function to avoid deserializing every method so we can
1750  // compute it.
1751  if (WasDefinition) {
1752  DeclID KeyFn = ReadDeclID(Record, Idx);
1753  if (KeyFn && D->IsCompleteDefinition)
1754  // FIXME: This is wrong for the ARM ABI, where some other module may have
1755  // made this function no longer be a key function. We need an update
1756  // record or similar for that case.
1757  C.KeyFunctions[D] = KeyFn;
1758  }
1759 
1760  return Redecl;
1761 }
1762 
1764  VisitFunctionDecl(D);
1765 
1766  unsigned NumOverridenMethods = Record[Idx++];
1767  if (D->isCanonicalDecl()) {
1768  while (NumOverridenMethods--) {
1769  // Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
1770  // MD may be initializing.
1771  if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
1772  Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
1773  }
1774  } else {
1775  // We don't care about which declarations this used to override; we get
1776  // the relevant information from the canonical declaration.
1777  Idx += NumOverridenMethods;
1778  }
1779 }
1780 
1782  // We need the inherited constructor information to merge the declaration,
1783  // so we have to read it before we call VisitCXXMethodDecl.
1784  if (D->isInheritingConstructor()) {
1785  auto *Shadow = ReadDeclAs<ConstructorUsingShadowDecl>(Record, Idx);
1786  auto *Ctor = ReadDeclAs<CXXConstructorDecl>(Record, Idx);
1787  *D->getTrailingObjects<InheritedConstructor>() =
1788  InheritedConstructor(Shadow, Ctor);
1789  }
1790 
1791  VisitCXXMethodDecl(D);
1792 
1793  D->IsExplicitSpecified = Record[Idx++];
1794 }
1795 
1797  VisitCXXMethodDecl(D);
1798 
1799  if (auto *OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx)) {
1800  auto *Canon = cast<CXXDestructorDecl>(D->getCanonicalDecl());
1801  // FIXME: Check consistency if we have an old and new operator delete.
1802  if (!Canon->OperatorDelete)
1803  Canon->OperatorDelete = OperatorDelete;
1804  }
1805 }
1806 
1808  VisitCXXMethodDecl(D);
1809  D->IsExplicitSpecified = Record[Idx++];
1810 }
1811 
1813  VisitDecl(D);
1814  D->ImportedAndComplete.setPointer(readModule(Record, Idx));
1815  D->ImportedAndComplete.setInt(Record[Idx++]);
1816  SourceLocation *StoredLocs = D->getTrailingObjects<SourceLocation>();
1817  for (unsigned I = 0, N = Record.back(); I != N; ++I)
1818  StoredLocs[I] = ReadSourceLocation(Record, Idx);
1819  ++Idx; // The number of stored source locations.
1820 }
1821 
1823  VisitDecl(D);
1824  D->setColonLoc(ReadSourceLocation(Record, Idx));
1825 }
1826 
1828  VisitDecl(D);
1829  if (Record[Idx++]) // hasFriendDecl
1830  D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1831  else
1832  D->Friend = GetTypeSourceInfo(Record, Idx);
1833  for (unsigned i = 0; i != D->NumTPLists; ++i)
1834  D->getTrailingObjects<TemplateParameterList *>()[i] =
1835  Reader.ReadTemplateParameterList(F, Record, Idx);
1836  D->NextFriend = ReadDeclID(Record, Idx);
1837  D->UnsupportedFriend = (Record[Idx++] != 0);
1838  D->FriendLoc = ReadSourceLocation(Record, Idx);
1839 }
1840 
1842  VisitDecl(D);
1843  unsigned NumParams = Record[Idx++];
1844  D->NumParams = NumParams;
1845  D->Params = new TemplateParameterList*[NumParams];
1846  for (unsigned i = 0; i != NumParams; ++i)
1847  D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
1848  if (Record[Idx++]) // HasFriendDecl
1849  D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
1850  else
1851  D->Friend = GetTypeSourceInfo(Record, Idx);
1852  D->FriendLoc = ReadSourceLocation(Record, Idx);
1853 }
1854 
1856  VisitNamedDecl(D);
1857 
1858  DeclID PatternID = ReadDeclID(Record, Idx);
1859  NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
1860  TemplateParameterList* TemplateParams
1861  = Reader.ReadTemplateParameterList(F, Record, Idx);
1862  D->init(TemplatedDecl, TemplateParams);
1863 
1864  return PatternID;
1865 }
1866 
1867 ASTDeclReader::RedeclarableResult
1869  RedeclarableResult Redecl = VisitRedeclarable(D);
1870 
1871  // Make sure we've allocated the Common pointer first. We do this before
1872  // VisitTemplateDecl so that getCommonPtr() can be used during initialization.
1874  if (!CanonD->Common) {
1875  CanonD->Common = CanonD->newCommon(Reader.getContext());
1876  Reader.PendingDefinitions.insert(CanonD);
1877  }
1878  D->Common = CanonD->Common;
1879 
1880  // If this is the first declaration of the template, fill in the information
1881  // for the 'common' pointer.
1882  if (ThisDeclID == Redecl.getFirstID()) {
1883  if (RedeclarableTemplateDecl *RTD
1884  = ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
1885  assert(RTD->getKind() == D->getKind() &&
1886  "InstantiatedFromMemberTemplate kind mismatch");
1888  if (Record[Idx++])
1890  }
1891  }
1892 
1893  DeclID PatternID = VisitTemplateDecl(D);
1894  D->IdentifierNamespace = Record[Idx++];
1895 
1896  mergeRedeclarable(D, Redecl, PatternID);
1897 
1898  // If we merged the template with a prior declaration chain, merge the common
1899  // pointer.
1900  // FIXME: Actually merge here, don't just overwrite.
1901  D->Common = D->getCanonicalDecl()->Common;
1902 
1903  return Redecl;
1904 }
1905 
1907  SmallVectorImpl<DeclID> &IDs) {
1908  assert(!IDs.empty() && "no IDs to add to list");
1909  if (Old) {
1910  IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]);
1911  std::sort(IDs.begin(), IDs.end());
1912  IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end());
1913  }
1914 
1915  auto *Result = new (Context) DeclID[1 + IDs.size()];
1916  *Result = IDs.size();
1917  std::copy(IDs.begin(), IDs.end(), Result + 1);
1918  return Result;
1919 }
1920 
1922  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1923 
1924  if (ThisDeclID == Redecl.getFirstID()) {
1925  // This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
1926  // the specializations.
1928  ReadDeclIDList(SpecIDs);
1929 
1930  if (!SpecIDs.empty()) {
1931  auto *CommonPtr = D->getCommonPtr();
1932  CommonPtr->LazySpecializations = newDeclIDList(
1933  Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1934  }
1935  }
1936 
1937  if (D->getTemplatedDecl()->TemplateOrInstantiation) {
1938  // We were loaded before our templated declaration was. We've not set up
1939  // its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
1940  // it now.
1941  Reader.Context.getInjectedClassNameType(
1943  }
1944 }
1945 
1947  llvm_unreachable("BuiltinTemplates are not serialized");
1948 }
1949 
1950 /// TODO: Unify with ClassTemplateDecl version?
1951 /// May require unifying ClassTemplateDecl and
1952 /// VarTemplateDecl beyond TemplateDecl...
1954  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
1955 
1956  if (ThisDeclID == Redecl.getFirstID()) {
1957  // This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
1958  // the specializations.
1960  ReadDeclIDList(SpecIDs);
1961 
1962  if (!SpecIDs.empty()) {
1963  auto *CommonPtr = D->getCommonPtr();
1964  CommonPtr->LazySpecializations = newDeclIDList(
1965  Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
1966  }
1967  }
1968 }
1969 
1970 ASTDeclReader::RedeclarableResult
1973  RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
1974 
1975  ASTContext &C = Reader.getContext();
1976  if (Decl *InstD = ReadDecl(Record, Idx)) {
1977  if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
1978  D->SpecializedTemplate = CTD;
1979  } else {
1981  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
1982  TemplateArgumentList *ArgList
1983  = TemplateArgumentList::CreateCopy(C, TemplArgs);
1984  ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
1986  SpecializedPartialSpecialization();
1987  PS->PartialSpecialization
1988  = cast<ClassTemplatePartialSpecializationDecl>(InstD);
1989  PS->TemplateArgs = ArgList;
1990  D->SpecializedTemplate = PS;
1991  }
1992  }
1993 
1995  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
1996  /*Canonicalize*/ true);
1997  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
1998  D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
1999  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
2000 
2001  bool writtenAsCanonicalDecl = Record[Idx++];
2002  if (writtenAsCanonicalDecl) {
2003  ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
2004  if (D->isCanonicalDecl()) { // It's kept in the folding set.
2005  // Set this as, or find, the canonical declaration for this specialization
2008  dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
2009  CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
2010  .GetOrInsertNode(Partial);
2011  } else {
2012  CanonSpec =
2013  CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2014  }
2015  // If there was already a canonical specialization, merge into it.
2016  if (CanonSpec != D) {
2017  mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
2018 
2019  // This declaration might be a definition. Merge with any existing
2020  // definition.
2021  if (auto *DDD = D->DefinitionData) {
2022  if (CanonSpec->DefinitionData)
2023  MergeDefinitionData(CanonSpec, std::move(*DDD));
2024  else
2025  CanonSpec->DefinitionData = D->DefinitionData;
2026  }
2027  D->DefinitionData = CanonSpec->DefinitionData;
2028  }
2029  }
2030  }
2031 
2032  // Explicit info.
2033  if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
2034  ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
2035  = new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
2036  ExplicitInfo->TypeAsWritten = TyInfo;
2037  ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
2038  ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
2039  D->ExplicitInfo = ExplicitInfo;
2040  }
2041 
2042  return Redecl;
2043 }
2044 
2047  RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
2048 
2049  D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2050  D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2051 
2052  // These are read/set from/to the first declaration.
2053  if (ThisDeclID == Redecl.getFirstID()) {
2054  D->InstantiatedFromMember.setPointer(
2055  ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
2056  D->InstantiatedFromMember.setInt(Record[Idx++]);
2057  }
2058 }
2059 
2062  VisitDecl(D);
2063  D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
2064 }
2065 
2067  RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
2068 
2069  if (ThisDeclID == Redecl.getFirstID()) {
2070  // This FunctionTemplateDecl owns a CommonPtr; read it.
2072  ReadDeclIDList(SpecIDs);
2073 
2074  if (!SpecIDs.empty()) {
2075  auto *CommonPtr = D->getCommonPtr();
2076  CommonPtr->LazySpecializations = newDeclIDList(
2077  Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
2078  }
2079  }
2080 }
2081 
2082 /// TODO: Unify with ClassTemplateSpecializationDecl version?
2083 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2084 /// VarTemplate(Partial)SpecializationDecl with a new data
2085 /// structure Template(Partial)SpecializationDecl, and
2086 /// using Template(Partial)SpecializationDecl as input type.
2087 ASTDeclReader::RedeclarableResult
2090  RedeclarableResult Redecl = VisitVarDeclImpl(D);
2091 
2092  ASTContext &C = Reader.getContext();
2093  if (Decl *InstD = ReadDecl(Record, Idx)) {
2094  if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
2095  D->SpecializedTemplate = VTD;
2096  } else {
2098  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
2100  C, TemplArgs);
2101  VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
2102  new (C)
2103  VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
2104  PS->PartialSpecialization =
2105  cast<VarTemplatePartialSpecializationDecl>(InstD);
2106  PS->TemplateArgs = ArgList;
2107  D->SpecializedTemplate = PS;
2108  }
2109  }
2110 
2111  // Explicit info.
2112  if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
2113  VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
2114  new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
2115  ExplicitInfo->TypeAsWritten = TyInfo;
2116  ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
2117  ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
2118  D->ExplicitInfo = ExplicitInfo;
2119  }
2120 
2122  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
2123  /*Canonicalize*/ true);
2124  D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs);
2125  D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
2126  D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
2127 
2128  bool writtenAsCanonicalDecl = Record[Idx++];
2129  if (writtenAsCanonicalDecl) {
2130  VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
2131  if (D->isCanonicalDecl()) { // It's kept in the folding set.
2132  // FIXME: If it's already present, merge it.
2134  dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
2135  CanonPattern->getCommonPtr()->PartialSpecializations
2136  .GetOrInsertNode(Partial);
2137  } else {
2138  CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
2139  }
2140  }
2141  }
2142 
2143  return Redecl;
2144 }
2145 
2146 /// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
2147 /// May require unifying ClassTemplate(Partial)SpecializationDecl and
2148 /// VarTemplate(Partial)SpecializationDecl with a new data
2149 /// structure Template(Partial)SpecializationDecl, and
2150 /// using Template(Partial)SpecializationDecl as input type.
2153  RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
2154 
2155  D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
2156  D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
2157 
2158  // These are read/set from/to the first declaration.
2159  if (ThisDeclID == Redecl.getFirstID()) {
2160  D->InstantiatedFromMember.setPointer(
2161  ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
2162  D->InstantiatedFromMember.setInt(Record[Idx++]);
2163  }
2164 }
2165 
2167  VisitTypeDecl(D);
2168 
2169  D->setDeclaredWithTypename(Record[Idx++]);
2170 
2171  if (Record[Idx++])
2172  D->setDefaultArgument(GetTypeSourceInfo(Record, Idx));
2173 }
2174 
2176  VisitDeclaratorDecl(D);
2177  // TemplateParmPosition.
2178  D->setDepth(Record[Idx++]);
2179  D->setPosition(Record[Idx++]);
2180  if (D->isExpandedParameterPack()) {
2181  auto TypesAndInfos =
2182  D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
2183  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
2184  new (&TypesAndInfos[I].first) QualType(Reader.readType(F, Record, Idx));
2185  TypesAndInfos[I].second = GetTypeSourceInfo(Record, Idx);
2186  }
2187  } else {
2188  // Rest of NonTypeTemplateParmDecl.
2189  D->ParameterPack = Record[Idx++];
2190  if (Record[Idx++])
2191  D->setDefaultArgument(Reader.ReadExpr(F));
2192  }
2193 }
2194 
2196  VisitTemplateDecl(D);
2197  // TemplateParmPosition.
2198  D->setDepth(Record[Idx++]);
2199  D->setPosition(Record[Idx++]);
2200  if (D->isExpandedParameterPack()) {
2201  TemplateParameterList **Data =
2202  D->getTrailingObjects<TemplateParameterList *>();
2203  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
2204  I != N; ++I)
2205  Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
2206  } else {
2207  // Rest of TemplateTemplateParmDecl.
2208  D->ParameterPack = Record[Idx++];
2209  if (Record[Idx++])
2210  D->setDefaultArgument(Reader.getContext(),
2211  Reader.ReadTemplateArgumentLoc(F, Record, Idx));
2212  }
2213 }
2214 
2216  VisitRedeclarableTemplateDecl(D);
2217 }
2218 
2220  VisitDecl(D);
2221  D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
2222  D->AssertExprAndFailed.setInt(Record[Idx++]);
2223  D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
2224  D->RParenLoc = ReadSourceLocation(Record, Idx);
2225 }
2226 
2228  VisitDecl(D);
2229 }
2230 
2231 std::pair<uint64_t, uint64_t>
2233  uint64_t LexicalOffset = ReadLocalOffset(Record, Idx);
2234  uint64_t VisibleOffset = ReadLocalOffset(Record, Idx);
2235  return std::make_pair(LexicalOffset, VisibleOffset);
2236 }
2237 
2238 template <typename T>
2239 ASTDeclReader::RedeclarableResult
2241  DeclID FirstDeclID = ReadDeclID(Record, Idx);
2242  Decl *MergeWith = nullptr;
2243 
2244  bool IsKeyDecl = ThisDeclID == FirstDeclID;
2245  bool IsFirstLocalDecl = false;
2246 
2247  uint64_t RedeclOffset = 0;
2248 
2249  // 0 indicates that this declaration was the only declaration of its entity,
2250  // and is used for space optimization.
2251  if (FirstDeclID == 0) {
2252  FirstDeclID = ThisDeclID;
2253  IsKeyDecl = true;
2254  IsFirstLocalDecl = true;
2255  } else if (unsigned N = Record[Idx++]) {
2256  // This declaration was the first local declaration, but may have imported
2257  // other declarations.
2258  IsKeyDecl = N == 1;
2259  IsFirstLocalDecl = true;
2260 
2261  // We have some declarations that must be before us in our redeclaration
2262  // chain. Read them now, and remember that we ought to merge with one of
2263  // them.
2264  // FIXME: Provide a known merge target to the second and subsequent such
2265  // declaration.
2266  for (unsigned I = 0; I != N - 1; ++I)
2267  MergeWith = ReadDecl(Record, Idx/*, MergeWith*/);
2268 
2269  RedeclOffset = ReadLocalOffset(Record, Idx);
2270  } else {
2271  // This declaration was not the first local declaration. Read the first
2272  // local declaration now, to trigger the import of other redeclarations.
2273  (void)ReadDecl(Record, Idx);
2274  }
2275 
2276  T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
2277  if (FirstDecl != D) {
2278  // We delay loading of the redeclaration chain to avoid deeply nested calls.
2279  // We temporarily set the first (canonical) declaration as the previous one
2280  // which is the one that matters and mark the real previous DeclID to be
2281  // loaded & attached later on.
2283  D->First = FirstDecl->getCanonicalDecl();
2284  }
2285 
2286  T *DAsT = static_cast<T*>(D);
2287 
2288  // Note that we need to load local redeclarations of this decl and build a
2289  // decl chain for them. This must happen *after* we perform the preloading
2290  // above; this ensures that the redeclaration chain is built in the correct
2291  // order.
2292  if (IsFirstLocalDecl)
2293  Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
2294 
2295  return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl);
2296 }
2297 
2298 /// \brief Attempts to merge the given declaration (D) with another declaration
2299 /// of the same entity.
2300 template<typename T>
2302  RedeclarableResult &Redecl,
2303  DeclID TemplatePatternID) {
2304  T *D = static_cast<T*>(DBase);
2305 
2306  // If modules are not available, there is no reason to perform this merge.
2307  if (!Reader.getContext().getLangOpts().Modules)
2308  return;
2309 
2310  // If we're not the canonical declaration, we don't need to merge.
2311  if (!DBase->isFirstDecl())
2312  return;
2313 
2314  if (auto *Existing = Redecl.getKnownMergeTarget())
2315  // We already know of an existing declaration we should merge with.
2316  mergeRedeclarable(D, cast<T>(Existing), Redecl, TemplatePatternID);
2317  else if (FindExistingResult ExistingRes = findExisting(D))
2318  if (T *Existing = ExistingRes)
2319  mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
2320 }
2321 
2322 /// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
2323 /// We use this to put code in a template that will only be valid for certain
2324 /// instantiations.
2325 template<typename T> static T assert_cast(T t) { return t; }
2326 template<typename T> static T assert_cast(...) {
2327  llvm_unreachable("bad assert_cast");
2328 }
2329 
2330 /// \brief Merge together the pattern declarations from two template
2331 /// declarations.
2333  RedeclarableTemplateDecl *Existing,
2334  DeclID DsID, bool IsKeyDecl) {
2335  auto *DPattern = D->getTemplatedDecl();
2336  auto *ExistingPattern = Existing->getTemplatedDecl();
2337  RedeclarableResult Result(DPattern->getCanonicalDecl()->getGlobalID(),
2338  /*MergeWith*/ ExistingPattern, IsKeyDecl);
2339 
2340  if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
2341  // Merge with any existing definition.
2342  // FIXME: This is duplicated in several places. Refactor.
2343  auto *ExistingClass =
2344  cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
2345  if (auto *DDD = DClass->DefinitionData) {
2346  if (ExistingClass->DefinitionData) {
2347  MergeDefinitionData(ExistingClass, std::move(*DDD));
2348  } else {
2349  ExistingClass->DefinitionData = DClass->DefinitionData;
2350  // We may have skipped this before because we thought that DClass
2351  // was the canonical declaration.
2352  Reader.PendingDefinitions.insert(DClass);
2353  }
2354  }
2355  DClass->DefinitionData = ExistingClass->DefinitionData;
2356 
2357  return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
2358  Result);
2359  }
2360  if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
2361  return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
2362  Result);
2363  if (auto *DVar = dyn_cast<VarDecl>(DPattern))
2364  return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
2365  if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
2366  return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
2367  Result);
2368  llvm_unreachable("merged an unknown kind of redeclarable template");
2369 }
2370 
2371 /// \brief Attempts to merge the given declaration (D) with another declaration
2372 /// of the same entity.
2373 template<typename T>
2375  RedeclarableResult &Redecl,
2376  DeclID TemplatePatternID) {
2377  T *D = static_cast<T*>(DBase);
2378  T *ExistingCanon = Existing->getCanonicalDecl();
2379  T *DCanon = D->getCanonicalDecl();
2380  if (ExistingCanon != DCanon) {
2381  assert(DCanon->getGlobalID() == Redecl.getFirstID() &&
2382  "already merged this declaration");
2383 
2384  // Have our redeclaration link point back at the canonical declaration
2385  // of the existing declaration, so that this declaration has the
2386  // appropriate canonical declaration.
2387  D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
2388  D->First = ExistingCanon;
2389  ExistingCanon->Used |= D->Used;
2390  D->Used = false;
2391 
2392  // When we merge a namespace, update its pointer to the first namespace.
2393  // We cannot have loaded any redeclarations of this declaration yet, so
2394  // there's nothing else that needs to be updated.
2395  if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
2396  Namespace->AnonOrFirstNamespaceAndInline.setPointer(
2397  assert_cast<NamespaceDecl*>(ExistingCanon));
2398 
2399  // When we merge a template, merge its pattern.
2400  if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
2401  mergeTemplatePattern(
2402  DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
2403  TemplatePatternID, Redecl.isKeyDecl());
2404 
2405  // If this declaration is a key declaration, make a note of that.
2406  if (Redecl.isKeyDecl())
2407  Reader.KeyDecls[ExistingCanon].push_back(Redecl.getFirstID());
2408  }
2409 }
2410 
2411 /// \brief Attempts to merge the given declaration (D) with another declaration
2412 /// of the same entity, for the case where the entity is not actually
2413 /// redeclarable. This happens, for instance, when merging the fields of
2414 /// identical class definitions from two different modules.
2415 template<typename T>
2417  // If modules are not available, there is no reason to perform this merge.
2418  if (!Reader.getContext().getLangOpts().Modules)
2419  return;
2420 
2421  // ODR-based merging is only performed in C++. In C, identically-named things
2422  // in different translation units are not redeclarations (but may still have
2423  // compatible types).
2424  if (!Reader.getContext().getLangOpts().CPlusPlus)
2425  return;
2426 
2427  if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
2428  if (T *Existing = ExistingRes)
2429  Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
2430  Existing->getCanonicalDecl());
2431 }
2432 
2434  VisitDecl(D);
2435  unsigned NumVars = D->varlist_size();
2437  Vars.reserve(NumVars);
2438  for (unsigned i = 0; i != NumVars; ++i) {
2439  Vars.push_back(Reader.ReadExpr(F));
2440  }
2441  D->setVars(Vars);
2442 }
2443 
2445  VisitValueDecl(D);
2446  D->setLocation(Reader.ReadSourceLocation(F, Record, Idx));
2447  D->setCombiner(Reader.ReadExpr(F));
2448  D->setInitializer(Reader.ReadExpr(F));
2449  D->PrevDeclInScope = Reader.ReadDeclID(F, Record, Idx);
2450 }
2451 
2453  VisitVarDecl(D);
2454 }
2455 
2456 //===----------------------------------------------------------------------===//
2457 // Attribute Reading
2458 //===----------------------------------------------------------------------===//
2459 
2460 /// \brief Reads attributes from the current stream position.
2462  const RecordData &Record, unsigned &Idx) {
2463  for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
2464  Attr *New = nullptr;
2465  attr::Kind Kind = (attr::Kind)Record[Idx++];
2466  SourceRange Range = ReadSourceRange(F, Record, Idx);
2467 
2468 #include "clang/Serialization/AttrPCHRead.inc"
2469 
2470  assert(New && "Unable to decode attribute?");
2471  Attrs.push_back(New);
2472  }
2473 }
2474 
2475 //===----------------------------------------------------------------------===//
2476 // ASTReader Implementation
2477 //===----------------------------------------------------------------------===//
2478 
2479 /// \brief Note that we have loaded the declaration with the given
2480 /// Index.
2481 ///
2482 /// This routine notes that this declaration has already been loaded,
2483 /// so that future GetDecl calls will return this declaration rather
2484 /// than trying to load a new declaration.
2485 inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
2486  assert(!DeclsLoaded[Index] && "Decl loaded twice?");
2487  DeclsLoaded[Index] = D;
2488 }
2489 
2490 
2491 /// \brief Determine whether the consumer will be interested in seeing
2492 /// this declaration (via HandleTopLevelDecl).
2493 ///
2494 /// This routine should return true for anything that might affect
2495 /// code generation, e.g., inline function definitions, Objective-C
2496 /// declarations with metadata, etc.
2497 static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
2498  // An ObjCMethodDecl is never considered as "interesting" because its
2499  // implementation container always is.
2500 
2501  if (isa<FileScopeAsmDecl>(D) ||
2502  isa<ObjCProtocolDecl>(D) ||
2503  isa<ObjCImplDecl>(D) ||
2504  isa<ImportDecl>(D) ||
2505  isa<PragmaCommentDecl>(D) ||
2506  isa<PragmaDetectMismatchDecl>(D))
2507  return true;
2508  if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareReductionDecl>(D))
2509  return !D->getDeclContext()->isFunctionOrMethod();
2510  if (VarDecl *Var = dyn_cast<VarDecl>(D))
2511  return Var->isFileVarDecl() &&
2512  Var->isThisDeclarationADefinition() == VarDecl::Definition;
2513  if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
2514  return Func->doesThisDeclarationHaveABody() || HasBody;
2515 
2516  return false;
2517 }
2518 
2519 /// \brief Get the correct cursor and offset for loading a declaration.
2520 ASTReader::RecordLocation
2521 ASTReader::DeclCursorForID(DeclID ID, SourceLocation &Loc) {
2522  GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
2523  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
2524  ModuleFile *M = I->second;
2525  const DeclOffset &DOffs =
2526  M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
2527  Loc = TranslateSourceLocation(*M, DOffs.getLocation());
2528  return RecordLocation(M, DOffs.BitOffset);
2529 }
2530 
2531 ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
2533  = GlobalBitOffsetsMap.find(GlobalOffset);
2534 
2535  assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
2536  return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
2537 }
2538 
2539 uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
2540  return LocalOffset + M.GlobalBitOffset;
2541 }
2542 
2544  const TemplateParameterList *Y);
2545 
2546 /// \brief Determine whether two template parameters are similar enough
2547 /// that they may be used in declarations of the same template.
2549  const NamedDecl *Y) {
2550  if (X->getKind() != Y->getKind())
2551  return false;
2552 
2553  if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
2554  const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
2555  return TX->isParameterPack() == TY->isParameterPack();
2556  }
2557 
2558  if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
2559  const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
2560  return TX->isParameterPack() == TY->isParameterPack() &&
2561  TX->getASTContext().hasSameType(TX->getType(), TY->getType());
2562  }
2563 
2564  const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
2565  const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
2566  return TX->isParameterPack() == TY->isParameterPack() &&
2568  TY->getTemplateParameters());
2569 }
2570 
2572  if (auto *NS = X->getAsNamespace())
2573  return NS;
2574  if (auto *NAS = X->getAsNamespaceAlias())
2575  return NAS->getNamespace();
2576  return nullptr;
2577 }
2578 
2580  const NestedNameSpecifier *Y) {
2581  if (auto *NSX = getNamespace(X)) {
2582  auto *NSY = getNamespace(Y);
2583  if (!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())
2584  return false;
2585  } else if (X->getKind() != Y->getKind())
2586  return false;
2587 
2588  // FIXME: For namespaces and types, we're permitted to check that the entity
2589  // is named via the same tokens. We should probably do so.
2590  switch (X->getKind()) {
2592  if (X->getAsIdentifier() != Y->getAsIdentifier())
2593  return false;
2594  break;
2597  // We've already checked that we named the same namespace.
2598  break;
2601  if (X->getAsType()->getCanonicalTypeInternal() !=
2603  return false;
2604  break;
2607  return true;
2608  }
2609 
2610  // Recurse into earlier portion of NNS, if any.
2611  auto *PX = X->getPrefix();
2612  auto *PY = Y->getPrefix();
2613  if (PX && PY)
2614  return isSameQualifier(PX, PY);
2615  return !PX && !PY;
2616 }
2617 
2618 /// \brief Determine whether two template parameter lists are similar enough
2619 /// that they may be used in declarations of the same template.
2621  const TemplateParameterList *Y) {
2622  if (X->size() != Y->size())
2623  return false;
2624 
2625  for (unsigned I = 0, N = X->size(); I != N; ++I)
2626  if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
2627  return false;
2628 
2629  return true;
2630 }
2631 
2632 /// \brief Determine whether the two declarations refer to the same entity.
2633 static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
2634  assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
2635 
2636  if (X == Y)
2637  return true;
2638 
2639  // Must be in the same context.
2640  if (!X->getDeclContext()->getRedeclContext()->Equals(
2641  Y->getDeclContext()->getRedeclContext()))
2642  return false;
2643 
2644  // Two typedefs refer to the same entity if they have the same underlying
2645  // type.
2646  if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
2647  if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
2648  return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
2649  TypedefY->getUnderlyingType());
2650 
2651  // Must have the same kind.
2652  if (X->getKind() != Y->getKind())
2653  return false;
2654 
2655  // Objective-C classes and protocols with the same name always match.
2656  if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
2657  return true;
2658 
2659  if (isa<ClassTemplateSpecializationDecl>(X)) {
2660  // No need to handle these here: we merge them when adding them to the
2661  // template.
2662  return false;
2663  }
2664 
2665  // Compatible tags match.
2666  if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
2667  TagDecl *TagY = cast<TagDecl>(Y);
2668  return (TagX->getTagKind() == TagY->getTagKind()) ||
2669  ((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
2670  TagX->getTagKind() == TTK_Interface) &&
2671  (TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
2672  TagY->getTagKind() == TTK_Interface));
2673  }
2674 
2675  // Functions with the same type and linkage match.
2676  // FIXME: This needs to cope with merging of prototyped/non-prototyped
2677  // functions, etc.
2678  if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
2679  FunctionDecl *FuncY = cast<FunctionDecl>(Y);
2680  if (CXXConstructorDecl *CtorX = dyn_cast<CXXConstructorDecl>(X)) {
2681  CXXConstructorDecl *CtorY = cast<CXXConstructorDecl>(Y);
2682  if (CtorX->getInheritedConstructor() &&
2683  !isSameEntity(CtorX->getInheritedConstructor().getConstructor(),
2685  return false;
2686  }
2687  return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
2688  FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
2689  }
2690 
2691  // Variables with the same type and linkage match.
2692  if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
2693  VarDecl *VarY = cast<VarDecl>(Y);
2694  if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
2695  ASTContext &C = VarX->getASTContext();
2696  if (C.hasSameType(VarX->getType(), VarY->getType()))
2697  return true;
2698 
2699  // We can get decls with different types on the redecl chain. Eg.
2700  // template <typename T> struct S { static T Var[]; }; // #1
2701  // template <typename T> T S<T>::Var[sizeof(T)]; // #2
2702  // Only? happens when completing an incomplete array type. In this case
2703  // when comparing #1 and #2 we should go through their element type.
2704  const ArrayType *VarXTy = C.getAsArrayType(VarX->getType());
2705  const ArrayType *VarYTy = C.getAsArrayType(VarY->getType());
2706  if (!VarXTy || !VarYTy)
2707  return false;
2708  if (VarXTy->isIncompleteArrayType() || VarYTy->isIncompleteArrayType())
2709  return C.hasSameType(VarXTy->getElementType(), VarYTy->getElementType());
2710  }
2711  return false;
2712  }
2713 
2714  // Namespaces with the same name and inlinedness match.
2715  if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
2716  NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
2717  return NamespaceX->isInline() == NamespaceY->isInline();
2718  }
2719 
2720  // Identical template names and kinds match if their template parameter lists
2721  // and patterns match.
2722  if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
2723  TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
2724  return isSameEntity(TemplateX->getTemplatedDecl(),
2725  TemplateY->getTemplatedDecl()) &&
2726  isSameTemplateParameterList(TemplateX->getTemplateParameters(),
2727  TemplateY->getTemplateParameters());
2728  }
2729 
2730  // Fields with the same name and the same type match.
2731  if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
2732  FieldDecl *FDY = cast<FieldDecl>(Y);
2733  // FIXME: Also check the bitwidth is odr-equivalent, if any.
2734  return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
2735  }
2736 
2737  // Indirect fields with the same target field match.
2738  if (auto *IFDX = dyn_cast<IndirectFieldDecl>(X)) {
2739  auto *IFDY = cast<IndirectFieldDecl>(Y);
2740  return IFDX->getAnonField()->getCanonicalDecl() ==
2741  IFDY->getAnonField()->getCanonicalDecl();
2742  }
2743 
2744  // Enumerators with the same name match.
2745  if (isa<EnumConstantDecl>(X))
2746  // FIXME: Also check the value is odr-equivalent.
2747  return true;
2748 
2749  // Using shadow declarations with the same target match.
2750  if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
2751  UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
2752  return USX->getTargetDecl() == USY->getTargetDecl();
2753  }
2754 
2755  // Using declarations with the same qualifier match. (We already know that
2756  // the name matches.)
2757  if (auto *UX = dyn_cast<UsingDecl>(X)) {
2758  auto *UY = cast<UsingDecl>(Y);
2759  return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2760  UX->hasTypename() == UY->hasTypename() &&
2761  UX->isAccessDeclaration() == UY->isAccessDeclaration();
2762  }
2763  if (auto *UX = dyn_cast<UnresolvedUsingValueDecl>(X)) {
2764  auto *UY = cast<UnresolvedUsingValueDecl>(Y);
2765  return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
2766  UX->isAccessDeclaration() == UY->isAccessDeclaration();
2767  }
2768  if (auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(X))
2769  return isSameQualifier(
2770  UX->getQualifier(),
2771  cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
2772 
2773  // Namespace alias definitions with the same target match.
2774  if (auto *NAX = dyn_cast<NamespaceAliasDecl>(X)) {
2775  auto *NAY = cast<NamespaceAliasDecl>(Y);
2776  return NAX->getNamespace()->Equals(NAY->getNamespace());
2777  }
2778 
2779  return false;
2780 }
2781 
2782 /// Find the context in which we should search for previous declarations when
2783 /// looking for declarations to merge.
2784 DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
2785  DeclContext *DC) {
2786  if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
2787  return ND->getOriginalNamespace();
2788 
2789  if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2790  // Try to dig out the definition.
2791  auto *DD = RD->DefinitionData;
2792  if (!DD)
2793  DD = RD->getCanonicalDecl()->DefinitionData;
2794 
2795  // If there's no definition yet, then DC's definition is added by an update
2796  // record, but we've not yet loaded that update record. In this case, we
2797  // commit to DC being the canonical definition now, and will fix this when
2798  // we load the update record.
2799  if (!DD) {
2800  DD = new (Reader.Context) struct CXXRecordDecl::DefinitionData(RD);
2801  RD->IsCompleteDefinition = true;
2802  RD->DefinitionData = DD;
2803  RD->getCanonicalDecl()->DefinitionData = DD;
2804 
2805  // Track that we did this horrible thing so that we can fix it later.
2806  Reader.PendingFakeDefinitionData.insert(
2807  std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));
2808  }
2809 
2810  return DD->Definition;
2811  }
2812 
2813  if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
2814  return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
2815  : nullptr;
2816 
2817  // We can see the TU here only if we have no Sema object. In that case,
2818  // there's no TU scope to look in, so using the DC alone is sufficient.
2819  if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
2820  return TU;
2821 
2822  return nullptr;
2823 }
2824 
2825 ASTDeclReader::FindExistingResult::~FindExistingResult() {
2826  // Record that we had a typedef name for linkage whether or not we merge
2827  // with that declaration.
2828  if (TypedefNameForLinkage) {
2829  DeclContext *DC = New->getDeclContext()->getRedeclContext();
2830  Reader.ImportedTypedefNamesForLinkage.insert(
2831  std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
2832  return;
2833  }
2834 
2835  if (!AddResult || Existing)
2836  return;
2837 
2838  DeclarationName Name = New->getDeclName();
2839  DeclContext *DC = New->getDeclContext()->getRedeclContext();
2841  setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
2842  AnonymousDeclNumber, New);
2843  } else if (DC->isTranslationUnit() &&
2844  !Reader.getContext().getLangOpts().CPlusPlus) {
2845  if (Reader.getIdResolver().tryAddTopLevelDecl(New, Name))
2846  Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
2847  .push_back(New);
2848  } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
2849  // Add the declaration to its redeclaration context so later merging
2850  // lookups will find it.
2851  MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
2852  }
2853 }
2854 
2855 /// Find the declaration that should be merged into, given the declaration found
2856 /// by name lookup. If we're merging an anonymous declaration within a typedef,
2857 /// we need a matching typedef, and we merge with the type inside it.
2859  bool IsTypedefNameForLinkage) {
2860  if (!IsTypedefNameForLinkage)
2861  return Found;
2862 
2863  // If we found a typedef declaration that gives a name to some other
2864  // declaration, then we want that inner declaration. Declarations from
2865  // AST files are handled via ImportedTypedefNamesForLinkage.
2866  if (Found->isFromASTFile())
2867  return nullptr;
2868 
2869  if (auto *TND = dyn_cast<TypedefNameDecl>(Found))
2870  return TND->getAnonDeclWithTypedefName();
2871 
2872  return nullptr;
2873 }
2874 
2875 NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
2876  DeclContext *DC,
2877  unsigned Index) {
2878  // If the lexical context has been merged, look into the now-canonical
2879  // definition.
2880  if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2881  DC = Merged;
2882 
2883  // If we've seen this before, return the canonical declaration.
2884  auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2885  if (Index < Previous.size() && Previous[Index])
2886  return Previous[Index];
2887 
2888  // If this is the first time, but we have parsed a declaration of the context,
2889  // build the anonymous declaration list from the parsed declaration.
2890  if (!cast<Decl>(DC)->isFromASTFile()) {
2891  numberAnonymousDeclsWithin(DC, [&](NamedDecl *ND, unsigned Number) {
2892  if (Previous.size() == Number)
2893  Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
2894  else
2895  Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());
2896  });
2897  }
2898 
2899  return Index < Previous.size() ? Previous[Index] : nullptr;
2900 }
2901 
2902 void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
2903  DeclContext *DC, unsigned Index,
2904  NamedDecl *D) {
2905  if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
2906  DC = Merged;
2907 
2908  auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
2909  if (Index >= Previous.size())
2910  Previous.resize(Index + 1);
2911  if (!Previous[Index])
2912  Previous[Index] = D;
2913 }
2914 
2915 ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
2916  DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
2917  : D->getDeclName();
2918 
2919  if (!Name && !needsAnonymousDeclarationNumber(D)) {
2920  // Don't bother trying to find unnamed declarations that are in
2921  // unmergeable contexts.
2922  FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
2923  AnonymousDeclNumber, TypedefNameForLinkage);
2924  Result.suppress();
2925  return Result;
2926  }
2927 
2928  DeclContext *DC = D->getDeclContext()->getRedeclContext();
2929  if (TypedefNameForLinkage) {
2930  auto It = Reader.ImportedTypedefNamesForLinkage.find(
2931  std::make_pair(DC, TypedefNameForLinkage));
2932  if (It != Reader.ImportedTypedefNamesForLinkage.end())
2933  if (isSameEntity(It->second, D))
2934  return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
2935  TypedefNameForLinkage);
2936  // Go on to check in other places in case an existing typedef name
2937  // was not imported.
2938  }
2939 
2941  // This is an anonymous declaration that we may need to merge. Look it up
2942  // in its context by number.
2943  if (auto *Existing = getAnonymousDeclForMerging(
2944  Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
2945  if (isSameEntity(Existing, D))
2946  return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2947  TypedefNameForLinkage);
2948  } else if (DC->isTranslationUnit() &&
2949  !Reader.getContext().getLangOpts().CPlusPlus) {
2950  IdentifierResolver &IdResolver = Reader.getIdResolver();
2951 
2952  // Temporarily consider the identifier to be up-to-date. We don't want to
2953  // cause additional lookups here.
2954  class UpToDateIdentifierRAII {
2955  IdentifierInfo *II;
2956  bool WasOutToDate;
2957 
2958  public:
2959  explicit UpToDateIdentifierRAII(IdentifierInfo *II)
2960  : II(II), WasOutToDate(false)
2961  {
2962  if (II) {
2963  WasOutToDate = II->isOutOfDate();
2964  if (WasOutToDate)
2965  II->setOutOfDate(false);
2966  }
2967  }
2968 
2969  ~UpToDateIdentifierRAII() {
2970  if (WasOutToDate)
2971  II->setOutOfDate(true);
2972  }
2973  } UpToDate(Name.getAsIdentifierInfo());
2974 
2975  for (IdentifierResolver::iterator I = IdResolver.begin(Name),
2976  IEnd = IdResolver.end();
2977  I != IEnd; ++I) {
2978  if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2979  if (isSameEntity(Existing, D))
2980  return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2981  TypedefNameForLinkage);
2982  }
2983  } else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
2984  DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
2985  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
2986  if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
2987  if (isSameEntity(Existing, D))
2988  return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
2989  TypedefNameForLinkage);
2990  }
2991  } else {
2992  // Not in a mergeable context.
2993  return FindExistingResult(Reader);
2994  }
2995 
2996  // If this declaration is from a merged context, make a note that we need to
2997  // check that the canonical definition of that context contains the decl.
2998  //
2999  // FIXME: We should do something similar if we merge two definitions of the
3000  // same template specialization into the same CXXRecordDecl.
3001  auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
3002  if (MergedDCIt != Reader.MergedDeclContexts.end() &&
3003  MergedDCIt->second == D->getDeclContext())
3004  Reader.PendingOdrMergeChecks.push_back(D);
3005 
3006  return FindExistingResult(Reader, D, /*Existing=*/nullptr,
3007  AnonymousDeclNumber, TypedefNameForLinkage);
3008 }
3009 
3010 template<typename DeclT>
3012  return D->RedeclLink.getLatestNotUpdated();
3013 }
3015  llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
3016 }
3017 
3019  assert(D);
3020 
3021  switch (D->getKind()) {
3022 #define ABSTRACT_DECL(TYPE)
3023 #define DECL(TYPE, BASE) \
3024  case Decl::TYPE: \
3025  return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
3026 #include "clang/AST/DeclNodes.inc"
3027  }
3028  llvm_unreachable("unknown decl kind");
3029 }
3030 
3031 Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
3032  return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());
3033 }
3034 
3035 template<typename DeclT>
3038  Decl *Previous, Decl *Canon) {
3039  D->RedeclLink.setPrevious(cast<DeclT>(Previous));
3040  D->First = cast<DeclT>(Previous)->First;
3041 }
3042 
3043 namespace clang {
3044 template<>
3047  Decl *Previous, Decl *Canon) {
3048  FunctionDecl *FD = static_cast<FunctionDecl*>(D);
3049  FunctionDecl *PrevFD = cast<FunctionDecl>(Previous);
3050 
3051  FD->RedeclLink.setPrevious(PrevFD);
3052  FD->First = PrevFD->First;
3053 
3054  // If the previous declaration is an inline function declaration, then this
3055  // declaration is too.
3056  if (PrevFD->IsInline != FD->IsInline) {
3057  // FIXME: [dcl.fct.spec]p4:
3058  // If a function with external linkage is declared inline in one
3059  // translation unit, it shall be declared inline in all translation
3060  // units in which it appears.
3061  //
3062  // Be careful of this case:
3063  //
3064  // module A:
3065  // template<typename T> struct X { void f(); };
3066  // template<typename T> inline void X<T>::f() {}
3067  //
3068  // module B instantiates the declaration of X<int>::f
3069  // module C instantiates the definition of X<int>::f
3070  //
3071  // If module B and C are merged, we do not have a violation of this rule.
3072  FD->IsInline = true;
3073  }
3074 
3075  // If we need to propagate an exception specification along the redecl
3076  // chain, make a note of that so that we can do so later.
3077  auto *FPT = FD->getType()->getAs<FunctionProtoType>();
3078  auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
3079  if (FPT && PrevFPT) {
3080  bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());
3081  bool WasUnresolved =
3083  if (IsUnresolved != WasUnresolved)
3084  Reader.PendingExceptionSpecUpdates.insert(
3085  std::make_pair(Canon, IsUnresolved ? PrevFD : FD));
3086  }
3087 }
3088 } // end namespace clang
3089 
3091  llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
3092 }
3093 
3094 /// Inherit the default template argument from \p From to \p To. Returns
3095 /// \c false if there is no default template for \p From.
3096 template <typename ParmDecl>
3098  Decl *ToD) {
3099  auto *To = cast<ParmDecl>(ToD);
3100  if (!From->hasDefaultArgument())
3101  return false;
3102  To->setInheritedDefaultArgument(Context, From);
3103  return true;
3104 }
3105 
3107  TemplateDecl *From,
3108  TemplateDecl *To) {
3109  auto *FromTP = From->getTemplateParameters();
3110  auto *ToTP = To->getTemplateParameters();
3111  assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
3112 
3113  for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
3114  NamedDecl *FromParam = FromTP->getParam(N - I - 1);
3115  if (FromParam->isParameterPack())
3116  continue;
3117  NamedDecl *ToParam = ToTP->getParam(N - I - 1);
3118 
3119  if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam)) {
3120  if (!inheritDefaultTemplateArgument(Context, FTTP, ToParam))
3121  break;
3122  } else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam)) {
3123  if (!inheritDefaultTemplateArgument(Context, FNTTP, ToParam))
3124  break;
3125  } else {
3127  Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam))
3128  break;
3129  }
3130  }
3131 }
3132 
3134  Decl *Previous, Decl *Canon) {
3135  assert(D && Previous);
3136 
3137  switch (D->getKind()) {
3138 #define ABSTRACT_DECL(TYPE)
3139 #define DECL(TYPE, BASE) \
3140  case Decl::TYPE: \
3141  attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
3142  break;
3143 #include "clang/AST/DeclNodes.inc"
3144  }
3145 
3146  // If the declaration was visible in one module, a redeclaration of it in
3147  // another module remains visible even if it wouldn't be visible by itself.
3148  //
3149  // FIXME: In this case, the declaration should only be visible if a module
3150  // that makes it visible has been imported.
3151  D->IdentifierNamespace |=
3152  Previous->IdentifierNamespace &
3153  (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
3154 
3155  // If the declaration declares a template, it may inherit default arguments
3156  // from the previous declaration.
3157  if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
3159  cast<TemplateDecl>(Previous), TD);
3160 }
3161 
3162 template<typename DeclT>
3164  D->RedeclLink.setLatest(cast<DeclT>(Latest));
3165 }
3167  llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
3168 }
3169 
3171  assert(D && Latest);
3172 
3173  switch (D->getKind()) {
3174 #define ABSTRACT_DECL(TYPE)
3175 #define DECL(TYPE, BASE) \
3176  case Decl::TYPE: \
3177  attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
3178  break;
3179 #include "clang/AST/DeclNodes.inc"
3180  }
3181 }
3182 
3183 template<typename DeclT>
3185  D->RedeclLink.markIncomplete();
3186 }
3188  llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
3189 }
3190 
3191 void ASTReader::markIncompleteDeclChain(Decl *D) {
3192  switch (D->getKind()) {
3193 #define ABSTRACT_DECL(TYPE)
3194 #define DECL(TYPE, BASE) \
3195  case Decl::TYPE: \
3196  ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
3197  break;
3198 #include "clang/AST/DeclNodes.inc"
3199  }
3200 }
3201 
3202 /// \brief Read the declaration at the given offset from the AST file.
3203 Decl *ASTReader::ReadDeclRecord(DeclID ID) {
3204  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
3205  SourceLocation DeclLoc;
3206  RecordLocation Loc = DeclCursorForID(ID, DeclLoc);
3207  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3208  // Keep track of where we are in the stream, then jump back there
3209  // after reading this declaration.
3210  SavedStreamPosition SavedPosition(DeclsCursor);
3211 
3212  ReadingKindTracker ReadingKind(Read_Decl, *this);
3213 
3214  // Note that we are loading a declaration record.
3215  Deserializing ADecl(this);
3216 
3217  DeclsCursor.JumpToBit(Loc.Offset);
3218  RecordData Record;
3219  unsigned Code = DeclsCursor.ReadCode();
3220  unsigned Idx = 0;
3221  ASTDeclReader Reader(*this, Loc, ID, DeclLoc, Record,Idx);
3222 
3223  Decl *D = nullptr;
3224  switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
3225  case DECL_CONTEXT_LEXICAL:
3226  case DECL_CONTEXT_VISIBLE:
3227  llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
3228  case DECL_TYPEDEF:
3230  break;
3231  case DECL_TYPEALIAS:
3233  break;
3234  case DECL_ENUM:
3236  break;
3237  case DECL_RECORD:
3239  break;
3240  case DECL_ENUM_CONSTANT:
3242  break;
3243  case DECL_FUNCTION:
3245  break;
3246  case DECL_LINKAGE_SPEC:
3248  break;
3249  case DECL_LABEL:
3251  break;
3252  case DECL_NAMESPACE:
3254  break;
3255  case DECL_NAMESPACE_ALIAS:
3257  break;
3258  case DECL_USING:
3260  break;
3261  case DECL_USING_SHADOW:
3263  break;
3266  break;
3267  case DECL_USING_DIRECTIVE:
3269  break;
3272  break;
3275  break;
3276  case DECL_CXX_RECORD:
3278  break;
3279  case DECL_CXX_METHOD:
3281  break;
3282  case DECL_CXX_CONSTRUCTOR:
3284  break;
3287  break;
3288  case DECL_CXX_DESTRUCTOR:
3290  break;
3291  case DECL_CXX_CONVERSION:
3293  break;
3294  case DECL_ACCESS_SPEC:
3296  break;
3297  case DECL_FRIEND:
3298  D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3299  break;
3300  case DECL_FRIEND_TEMPLATE:
3302  break;
3303  case DECL_CLASS_TEMPLATE:
3305  break;
3308  break;
3311  break;
3312  case DECL_VAR_TEMPLATE:
3314  break;
3317  break;
3320  break;
3323  break;
3326  break;
3329  break;
3332  break;
3334  D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3335  break;
3338  break;
3341  Record[Idx++]);
3342  break;
3345  break;
3346  case DECL_STATIC_ASSERT:
3348  break;
3349  case DECL_OBJC_METHOD:
3351  break;
3352  case DECL_OBJC_INTERFACE:
3354  break;
3355  case DECL_OBJC_IVAR:
3357  break;
3358  case DECL_OBJC_PROTOCOL:
3360  break;
3363  break;
3364  case DECL_OBJC_CATEGORY:
3366  break;
3369  break;
3372  break;
3375  break;
3376  case DECL_OBJC_PROPERTY:
3378  break;
3381  break;
3382  case DECL_FIELD:
3384  break;
3385  case DECL_INDIRECTFIELD:
3387  break;
3388  case DECL_VAR:
3390  break;
3391  case DECL_IMPLICIT_PARAM:
3393  break;
3394  case DECL_PARM_VAR:
3396  break;
3397  case DECL_FILE_SCOPE_ASM:
3399  break;
3400  case DECL_BLOCK:
3402  break;
3403  case DECL_MS_PROPERTY:
3405  break;
3406  case DECL_CAPTURED:
3407  D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3408  break;
3410  Error("attempt to read a C++ base-specifier record as a declaration");
3411  return nullptr;
3413  Error("attempt to read a C++ ctor initializer record as a declaration");
3414  return nullptr;
3415  case DECL_IMPORT:
3416  // Note: last entry of the ImportDecl record is the number of stored source
3417  // locations.
3418  D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
3419  break;
3421  D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3422  break;
3425  break;
3426  case DECL_OMP_CAPTUREDEXPR:
3428  break;
3429  case DECL_PRAGMA_COMMENT:
3430  D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record[Idx++]);
3431  break;
3434  Record[Idx++]);
3435  break;
3436  case DECL_EMPTY:
3438  break;
3439  case DECL_OBJC_TYPE_PARAM:
3441  break;
3442  }
3443 
3444  assert(D && "Unknown declaration reading AST file");
3445  LoadedDecl(Index, D);
3446  // Set the DeclContext before doing any deserialization, to make sure internal
3447  // calls to Decl::getASTContext() by Decl's methods will find the
3448  // TranslationUnitDecl without crashing.
3449  D->setDeclContext(Context.getTranslationUnitDecl());
3450  Reader.Visit(D);
3451 
3452  // If this declaration is also a declaration context, get the
3453  // offsets for its tables of lexical and visible declarations.
3454  if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
3455  std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
3456  if (Offsets.first &&
3457  ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, Offsets.first, DC))
3458  return nullptr;
3459  if (Offsets.second &&
3460  ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, Offsets.second, ID))
3461  return nullptr;
3462  }
3463  assert(Idx == Record.size());
3464 
3465  // Load any relevant update records.
3466  PendingUpdateRecords.push_back(std::make_pair(ID, D));
3467 
3468  // Load the categories after recursive loading is finished.
3469  if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
3470  if (Class->isThisDeclarationADefinition())
3471  loadObjCCategories(ID, Class);
3472 
3473  // If we have deserialized a declaration that has a definition the
3474  // AST consumer might need to know about, queue it.
3475  // We don't pass it to the consumer immediately because we may be in recursive
3476  // loading, and some declarations may still be initializing.
3477  if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
3478  InterestingDecls.push_back(D);
3479 
3480  return D;
3481 }
3482 
3483 void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
3484  // The declaration may have been modified by files later in the chain.
3485  // If this is the case, read the record containing the updates from each file
3486  // and pass it to ASTDeclReader to make the modifications.
3487  ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
3488  DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
3489  if (UpdI != DeclUpdateOffsets.end()) {
3490  auto UpdateOffsets = std::move(UpdI->second);
3491  DeclUpdateOffsets.erase(UpdI);
3492 
3493  bool WasInteresting = isConsumerInterestedIn(D, false);
3494  for (auto &FileAndOffset : UpdateOffsets) {
3495  ModuleFile *F = FileAndOffset.first;
3496  uint64_t Offset = FileAndOffset.second;
3497  llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3498  SavedStreamPosition SavedPosition(Cursor);
3499  Cursor.JumpToBit(Offset);
3500  RecordData Record;
3501  unsigned Code = Cursor.ReadCode();
3502  unsigned RecCode = Cursor.readRecord(Code, Record);
3503  (void)RecCode;
3504  assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
3505 
3506  unsigned Idx = 0;
3507  ASTDeclReader Reader(*this, RecordLocation(F, Offset), ID,
3508  SourceLocation(), Record, Idx);
3509  Reader.UpdateDecl(D, *F, Record);
3510 
3511  // We might have made this declaration interesting. If so, remember that
3512  // we need to hand it off to the consumer.
3513  if (!WasInteresting &&
3514  isConsumerInterestedIn(D, Reader.hasPendingBody())) {
3515  InterestingDecls.push_back(D);
3516  WasInteresting = true;
3517  }
3518  }
3519  }
3520 
3521  // Load the pending visible updates for this decl context, if it has any.
3522  auto I = PendingVisibleUpdates.find(ID);
3523  if (I != PendingVisibleUpdates.end()) {
3524  auto VisibleUpdates = std::move(I->second);
3525  PendingVisibleUpdates.erase(I);
3526 
3527  auto *DC = cast<DeclContext>(D)->getPrimaryContext();
3528  for (const PendingVisibleUpdate &Update : VisibleUpdates)
3529  Lookups[DC].Table.add(
3530  Update.Mod, Update.Data,
3531  reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
3532  DC->setHasExternalVisibleStorage(true);
3533  }
3534 }
3535 
3536 void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
3537  // Attach FirstLocal to the end of the decl chain.
3538  Decl *CanonDecl = FirstLocal->getCanonicalDecl();
3539  if (FirstLocal != CanonDecl) {
3540  Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);
3542  *this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
3543  CanonDecl);
3544  }
3545 
3546  if (!LocalOffset) {
3547  ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);
3548  return;
3549  }
3550 
3551  // Load the list of other redeclarations from this module file.
3552  ModuleFile *M = getOwningModuleFile(FirstLocal);
3553  assert(M && "imported decl from no module file");
3554 
3555  llvm::BitstreamCursor &Cursor = M->DeclsCursor;
3556  SavedStreamPosition SavedPosition(Cursor);
3557  Cursor.JumpToBit(LocalOffset);
3558 
3559  RecordData Record;
3560  unsigned Code = Cursor.ReadCode();
3561  unsigned RecCode = Cursor.readRecord(Code, Record);
3562  (void)RecCode;
3563  assert(RecCode == LOCAL_REDECLARATIONS && "expected LOCAL_REDECLARATIONS record!");
3564 
3565  // FIXME: We have several different dispatches on decl kind here; maybe
3566  // we should instead generate one loop per kind and dispatch up-front?
3567  Decl *MostRecent = FirstLocal;
3568  for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3569  auto *D = GetLocalDecl(*M, Record[N - I - 1]);
3570  ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
3571  MostRecent = D;
3572  }
3573  ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
3574 }
3575 
3576 namespace {
3577  /// \brief Given an ObjC interface, goes through the modules and links to the
3578  /// interface all the categories for it.
3579  class ObjCCategoriesVisitor {
3580  ASTReader &Reader;
3581  serialization::GlobalDeclID InterfaceID;
3582  ObjCInterfaceDecl *Interface;
3583  llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
3584  unsigned PreviousGeneration;
3585  ObjCCategoryDecl *Tail;
3586  llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
3587 
3588  void add(ObjCCategoryDecl *Cat) {
3589  // Only process each category once.
3590  if (!Deserialized.erase(Cat))
3591  return;
3592 
3593  // Check for duplicate categories.
3594  if (Cat->getDeclName()) {
3595  ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
3596  if (Existing &&
3597  Reader.getOwningModuleFile(Existing)
3598  != Reader.getOwningModuleFile(Cat)) {
3599  // FIXME: We should not warn for duplicates in diamond:
3600  //
3601  // MT //
3602  // / \ //
3603  // ML MR //
3604  // \ / //
3605  // MB //
3606  //
3607  // If there are duplicates in ML/MR, there will be warning when
3608  // creating MB *and* when importing MB. We should not warn when
3609  // importing.
3610  Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
3611  << Interface->getDeclName() << Cat->getDeclName();
3612  Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
3613  } else if (!Existing) {
3614  // Record this category.
3615  Existing = Cat;
3616  }
3617  }
3618 
3619  // Add this category to the end of the chain.
3620  if (Tail)
3622  else
3623  Interface->setCategoryListRaw(Cat);
3624  Tail = Cat;
3625  }
3626 
3627  public:
3628  ObjCCategoriesVisitor(ASTReader &Reader,
3629  serialization::GlobalDeclID InterfaceID,
3630  ObjCInterfaceDecl *Interface,
3631  llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
3632  unsigned PreviousGeneration)
3633  : Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
3634  Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
3635  Tail(nullptr)
3636  {
3637  // Populate the name -> category map with the set of known categories.
3638  for (auto *Cat : Interface->known_categories()) {
3639  if (Cat->getDeclName())
3640  NameCategoryMap[Cat->getDeclName()] = Cat;
3641 
3642  // Keep track of the tail of the category list.
3643  Tail = Cat;
3644  }
3645  }
3646 
3647  bool operator()(ModuleFile &M) {
3648  // If we've loaded all of the category information we care about from
3649  // this module file, we're done.
3650  if (M.Generation <= PreviousGeneration)
3651  return true;
3652 
3653  // Map global ID of the definition down to the local ID used in this
3654  // module file. If there is no such mapping, we'll find nothing here
3655  // (or in any module it imports).
3656  DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
3657  if (!LocalID)
3658  return true;
3659 
3660  // Perform a binary search to find the local redeclarations for this
3661  // declaration (if any).
3662  const ObjCCategoriesInfo Compare = { LocalID, 0 };
3663  const ObjCCategoriesInfo *Result
3664  = std::lower_bound(M.ObjCCategoriesMap,
3666  Compare);
3667  if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
3668  Result->DefinitionID != LocalID) {
3669  // We didn't find anything. If the class definition is in this module
3670  // file, then the module files it depends on cannot have any categories,
3671  // so suppress further lookup.
3672  return Reader.isDeclIDFromModule(InterfaceID, M);
3673  }
3674 
3675  // We found something. Dig out all of the categories.
3676  unsigned Offset = Result->Offset;
3677  unsigned N = M.ObjCCategories[Offset];
3678  M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
3679  for (unsigned I = 0; I != N; ++I)
3680  add(cast_or_null<ObjCCategoryDecl>(
3681  Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
3682  return true;
3683  }
3684  };
3685 } // end anonymous namespace
3686 
3687 void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
3688  ObjCInterfaceDecl *D,
3689  unsigned PreviousGeneration) {
3690  ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
3691  PreviousGeneration);
3692  ModuleMgr.visit(Visitor);
3693 }
3694 
3695 template<typename DeclT, typename Fn>
3696 static void forAllLaterRedecls(DeclT *D, Fn F) {
3697  F(D);
3698 
3699  // Check whether we've already merged D into its redeclaration chain.
3700  // MostRecent may or may not be nullptr if D has not been merged. If
3701  // not, walk the merged redecl chain and see if it's there.
3702  auto *MostRecent = D->getMostRecentDecl();
3703  bool Found = false;
3704  for (auto *Redecl = MostRecent; Redecl && !Found;
3705  Redecl = Redecl->getPreviousDecl())
3706  Found = (Redecl == D);
3707 
3708  // If this declaration is merged, apply the functor to all later decls.
3709  if (Found) {
3710  for (auto *Redecl = MostRecent; Redecl != D;
3711  Redecl = Redecl->getPreviousDecl())
3712  F(Redecl);
3713  }
3714 }
3715 
3716 void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
3717  const RecordData &Record) {
3718  while (Idx < Record.size()) {
3719  switch ((DeclUpdateKind)Record[Idx++]) {
3721  auto *RD = cast<CXXRecordDecl>(D);
3722  // FIXME: If we also have an update record for instantiating the
3723  // definition of D, we need that to happen before we get here.
3724  Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
3725  assert(MD && "couldn't read decl from update record");
3726  // FIXME: We should call addHiddenDecl instead, to add the member
3727  // to its DeclContext.
3728  RD->addedMember(MD);
3729  break;
3730  }
3731 
3733  // It will be added to the template's specializations set when loaded.
3734  (void)Reader.ReadDecl(ModuleFile, Record, Idx);
3735  break;
3736 
3738  NamespaceDecl *Anon
3739  = Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
3740 
3741  // Each module has its own anonymous namespace, which is disjoint from
3742  // any other module's anonymous namespaces, so don't attach the anonymous
3743  // namespace at all.
3744  if (ModuleFile.Kind != MK_ImplicitModule &&
3745  ModuleFile.Kind != MK_ExplicitModule) {
3746  if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
3747  TU->setAnonymousNamespace(Anon);
3748  else
3749  cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
3750  }
3751  break;
3752  }
3753 
3755  cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
3756  Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3757  break;
3758 
3760  auto Param = cast<ParmVarDecl>(D);
3761 
3762  // We have to read the default argument regardless of whether we use it
3763  // so that hypothetical further update records aren't messed up.
3764  // TODO: Add a function to skip over the next expr record.
3765  auto DefaultArg = Reader.ReadExpr(F);
3766 
3767  // Only apply the update if the parameter still has an uninstantiated
3768  // default argument.
3769  if (Param->hasUninstantiatedDefaultArg())
3770  Param->setDefaultArg(DefaultArg);
3771  break;
3772  }
3773 
3775  FunctionDecl *FD = cast<FunctionDecl>(D);
3776  if (Reader.PendingBodies[FD]) {
3777  // FIXME: Maybe check for ODR violations.
3778  // It's safe to stop now because this update record is always last.
3779  return;
3780  }
3781 
3782  if (Record[Idx++]) {
3783  // Maintain AST consistency: any later redeclarations of this function
3784  // are inline if this one is. (We might have merged another declaration
3785  // into this one.)
3786  forAllLaterRedecls(FD, [](FunctionDecl *FD) {
3787  FD->setImplicitlyInline();
3788  });
3789  }
3790  FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3791  if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
3792  CD->NumCtorInitializers = Record[Idx++];
3793  if (CD->NumCtorInitializers)
3794  CD->CtorInitializers = ReadGlobalOffset(F, Record, Idx);
3795  }
3796  // Store the offset of the body so we can lazily load it later.
3797  Reader.PendingBodies[FD] = GetCurrentCursorOffset();
3798  HasPendingBody = true;
3799  assert(Idx == Record.size() && "lazy body must be last");
3800  break;
3801  }
3802 
3804  auto *RD = cast<CXXRecordDecl>(D);
3805  auto *OldDD = RD->getCanonicalDecl()->DefinitionData;
3806  bool HadRealDefinition =
3807  OldDD && (OldDD->Definition != RD ||
3808  !Reader.PendingFakeDefinitionData.count(OldDD));
3809  ReadCXXRecordDefinition(RD, /*Update*/true);
3810 
3811  // Visible update is handled separately.
3812  uint64_t LexicalOffset = ReadLocalOffset(Record, Idx);
3813  if (!HadRealDefinition && LexicalOffset) {
3814  Reader.ReadLexicalDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
3815  LexicalOffset, RD);
3816  Reader.PendingFakeDefinitionData.erase(OldDD);
3817  }
3818 
3819  auto TSK = (TemplateSpecializationKind)Record[Idx++];
3820  SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
3821  if (MemberSpecializationInfo *MSInfo =
3822  RD->getMemberSpecializationInfo()) {
3823  MSInfo->setTemplateSpecializationKind(TSK);
3824  MSInfo->setPointOfInstantiation(POI);
3825  } else {
3827  cast<ClassTemplateSpecializationDecl>(RD);
3828  Spec->setTemplateSpecializationKind(TSK);
3829  Spec->setPointOfInstantiation(POI);
3830 
3831  if (Record[Idx++]) {
3832  auto PartialSpec =
3833  ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
3835  Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
3836  auto *TemplArgList = TemplateArgumentList::CreateCopy(
3837  Reader.getContext(), TemplArgs);
3838 
3839  // FIXME: If we already have a partial specialization set,
3840  // check that it matches.
3841  if (!Spec->getSpecializedTemplateOrPartial()
3843  Spec->setInstantiationOf(PartialSpec, TemplArgList);
3844  }
3845  }
3846 
3847  RD->setTagKind((TagTypeKind)Record[Idx++]);
3848  RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3849  RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
3850  RD->setBraceRange(Reader.ReadSourceRange(ModuleFile, Record, Idx));
3851 
3852  if (Record[Idx++]) {
3853  AttrVec Attrs;
3854  Reader.ReadAttributes(F, Attrs, Record, Idx);
3855  D->setAttrsImpl(Attrs, Reader.getContext());
3856  }
3857  break;
3858  }
3859 
3861  // Set the 'operator delete' directly to avoid emitting another update
3862  // record.
3863  auto *Del = Reader.ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
3864  auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
3865  // FIXME: Check consistency if we have an old and new operator delete.
3866  if (!First->OperatorDelete)
3867  First->OperatorDelete = Del;
3868  break;
3869  }
3870 
3873  SmallVector<QualType, 8> ExceptionStorage;
3874  Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
3875 
3876  // Update this declaration's exception specification, if needed.
3877  auto *FD = cast<FunctionDecl>(D);
3878  auto *FPT = FD->getType()->castAs<FunctionProtoType>();
3879  // FIXME: If the exception specification is already present, check that it
3880  // matches.
3881  if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
3882  FD->setType(Reader.Context.getFunctionType(
3883  FPT->getReturnType(), FPT->getParamTypes(),
3884  FPT->getExtProtoInfo().withExceptionSpec(ESI)));
3885 
3886  // When we get to the end of deserializing, see if there are other decls
3887  // that we need to propagate this exception specification onto.
3888  Reader.PendingExceptionSpecUpdates.insert(
3889  std::make_pair(FD->getCanonicalDecl(), FD));
3890  }
3891  break;
3892  }
3893 
3895  // FIXME: Also do this when merging redecls.
3896  QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
3897  for (auto *Redecl : merged_redecls(D)) {
3898  // FIXME: If the return type is already deduced, check that it matches.
3899  FunctionDecl *FD = cast<FunctionDecl>(Redecl);
3900  Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
3901  }
3902  break;
3903  }
3904 
3905  case UPD_DECL_MARKED_USED: {
3906  // Maintain AST consistency: any later redeclarations are used too.
3907  D->markUsed(Reader.Context);
3908  break;
3909  }
3910 
3911  case UPD_MANGLING_NUMBER:
3912  Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
3913  break;
3914 
3916  Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
3917  break;
3918 
3920  D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
3921  Reader.Context, ReadSourceRange(Record, Idx)));
3922  break;
3923 
3924  case UPD_DECL_EXPORTED: {
3925  unsigned SubmoduleID = readSubmoduleID(Record, Idx);
3926  auto *Exported = cast<NamedDecl>(D);
3927  if (auto *TD = dyn_cast<TagDecl>(Exported))
3928  Exported = TD->getDefinition();
3929  Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
3930  if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
3931  Reader.getContext().mergeDefinitionIntoModule(cast<NamedDecl>(Exported),
3932  Owner);
3933  Reader.PendingMergedDefinitionsToDeduplicate.insert(
3934  cast<NamedDecl>(Exported));
3935  } else if (Owner && Owner->NameVisibility != Module::AllVisible) {
3936  // If Owner is made visible at some later point, make this declaration
3937  // visible too.
3938  Reader.HiddenNamesMap[Owner].push_back(Exported);
3939  } else {
3940  // The declaration is now visible.
3941  Exported->Hidden = false;
3942  }
3943  break;
3944  }
3945 
3948  AttrVec Attrs;
3949  Reader.ReadAttributes(F, Attrs, Record, Idx);
3950  assert(Attrs.size() == 1);
3951  D->addAttr(Attrs[0]);
3952  break;
3953  }
3954  }
3955 }
RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD)
void VisitTypeDecl(TypeDecl *TD)
void setCategoryNameLoc(SourceLocation Loc)
Definition: DeclObjC.h:2294
A FriendTemplateDecl record.
Definition: ASTBitCodes.h:1117
Defines the clang::ASTContext interface.
A NonTypeTemplateParmDecl record.
Definition: ASTBitCodes.h:1135
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1410
Decl * GetLocalDecl(ModuleFile &F, uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
Definition: ASTReader.h:1671
bool hasPendingBody() const
Determine whether this declaration has a pending body.
void VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D)
static const Decl * getCanonicalDecl(const Decl *D)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
iterator begin() const
Definition: DeclBase.h:1103
void VisitVarDecl(VarDecl *VD)
#define MATCH_FIELD(Field)
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3321
A class which contains all the information about a particular captured value.
Definition: Decl.h:3460
static ImportDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
Definition: Decl.cpp:4263
void VisitImportDecl(ImportDecl *D)
A (possibly-)qualified type.
Definition: Type.h:598
void mergeMergeable(Mergeable< T > *D)
Attempts to merge the given declaration (D) with another declaration of the same entity, for the case where the entity is not actually redeclarable.
static ObjCIvarDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1713
FunctionDecl * Function
The function template specialization that this structure describes.
Definition: DeclTemplate.h:422
void setDefaultArgument(TypeSourceInfo *DefArg)
Set the default argument for this template parameter.
void VisitUsingDecl(UsingDecl *D)
static UnresolvedUsingValueDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2268
static VarDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:1807
void setLParenLoc(SourceLocation L)
Definition: DeclObjC.h:777
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...
void VisitFieldDecl(FieldDecl *FD)
void VisitImplicitParamDecl(ImplicitParamDecl *PD)
An OMPThreadPrivateDecl record.
Definition: ASTBitCodes.h:1160
void VisitObjCIvarDecl(ObjCIvarDecl *D)
#define OR_FIELD(Field)
void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D)
bool isParameterPack() const
Returns whether this is a parameter pack.
static void setNextObjCCategory(ObjCCategoryDecl *Cat, ObjCCategoryDecl *Next)
bool IsICE
Whether this statement is an integral constant expression, or in C++11, whether the statement is a co...
Definition: Decl.h:760
RedeclarableResult VisitClassTemplateSpecializationDeclImpl(ClassTemplateSpecializationDecl *D)
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2481
void setEmbeddedInDeclarator(bool isInDeclarator)
Definition: Decl.h:2889
No linkage, which means that the entity is unique and can only be referred to from within its scope...
Definition: Linkage.h:28
unsigned Generation
The generation of which this module file is a part.
static AccessSpecDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:33
TypedefDecl - Represents the declaration of a typedef-name via the 'typedef' type specifier...
Definition: Decl.h:2681
void setParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:3670
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
An OMPDeclareReductionDecl record.
Definition: ASTBitCodes.h:1172
void VisitEnumConstantDecl(EnumConstantDecl *ECD)
static PragmaCommentDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned ArgSize)
Definition: Decl.cpp:3939
static void attachLatestDeclImpl(Redeclarable< DeclT > *D, Decl *Latest)
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:7560
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3053
static NamedDecl * getDeclForMerging(NamedDecl *Found, bool IsTypedefNameForLinkage)
Find the declaration that should be merged into, given the declaration found by name lookup...
A VarTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1129
void setDefaultArgument(const ASTContext &C, const TemplateArgumentLoc &DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
Defines the C++ template declaration subclasses.
static Decl * getMostRecentDecl(Decl *D)
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3230
void VisitCXXDestructorDecl(CXXDestructorDecl *D)
void VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
A record that stores the set of declarations that are lexically stored within a given DeclContext...
Definition: ASTBitCodes.h:1070
void VisitObjCCategoryDecl(ObjCCategoryDecl *D)
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn't a simple identifier.
Represents an empty-declaration.
Definition: Decl.h:3788
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:63
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
Class that performs name lookup into a DeclContext stored in an AST file.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
Declaration of a variable template.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:471
A ObjCPropertyDecl record.
Definition: ASTBitCodes.h:1043
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
void setPropertyImplementation(PropertyControl pc)
Definition: DeclObjC.h:867
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:101
static FriendDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned FriendTypeNumTPLists)
Definition: DeclFriend.cpp:58
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:93
A container of type source information.
Definition: Decl.h:62
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
void setPropertyAccessor(bool isAccessor)
Definition: DeclObjC.h:422
static void inheritDefaultTemplateArguments(ASTContext &Context, TemplateDecl *From, TemplateDecl *To)
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
static CapturedDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumParams)
Definition: Decl.cpp:4068
Represents a #pragma comment line.
Definition: Decl.h:109
A ClassTemplateDecl record.
Definition: ASTBitCodes.h:1119
void VisitStaticAssertDecl(StaticAssertDecl *D)
A PragmaDetectMismatchDecl record.
Definition: ASTBitCodes.h:1170
An UnresolvedUsingTypenameDecl record.
Definition: ASTBitCodes.h:1096
An identifier, stored as an IdentifierInfo*.
void setNothrow(bool Nothrow=true)
Definition: Decl.cpp:4078
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:543
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:40
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
void VisitNamedDecl(NamedDecl *ND)
Declaration of a redeclarable template.
Definition: DeclTemplate.h:629
An OMPCapturedExprDecl record.
Definition: ASTBitCodes.h:1166
A UsingShadowDecl record.
Definition: ASTBitCodes.h:1088
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
Definition: ASTBitCodes.h:995
The "__interface" keyword.
Definition: Type.h:4346
Represents a variable template specialization, which refers to a variable template with a given set o...
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack...
Definition: ASTBitCodes.h:1153
A namespace, stored as a NamespaceDecl*.
void VisitClassTemplateDecl(ClassTemplateDecl *D)
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.cpp:3877
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:49
void setSelfDecl(ImplicitParamDecl *SD)
Definition: DeclObjC.h:407
void VisitTypeAliasDecl(TypeAliasDecl *TD)
A TemplateTemplateParmDecl record.
Definition: ASTBitCodes.h:1137
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
A ObjCInterfaceDecl record.
Definition: ASTBitCodes.h:1027
T * ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1711
void setHasExternalVisibleStorage(bool ES=true)
State whether this DeclContext has external storage for declarations visible in this context...
Definition: DeclBase.h:1770
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:2889
RedeclarableResult VisitTagDecl(TagDecl *TD)
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form, which contains extra information on the evaluated value of the initializer.
Definition: Decl.cpp:2120
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name 'Name'.
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1322
static void attachPreviousDeclImpl(ASTReader &Reader, Redeclarable< DeclT > *D, Decl *Previous, Decl *Canon)
A CXXConstructorDecl record for an inherited constructor.
Definition: ASTBitCodes.h:1106
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2161
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:27
ObjCProtocolDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C protocol.
Definition: DeclObjC.h:2137
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3146
void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D)
void mergeRedeclarable(Redeclarable< T > *D, RedeclarableResult &Redecl, DeclID TemplatePatternID=0)
Attempts to merge the given declaration (D) with another declaration of the same entity.
static OMPThreadPrivateDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned N)
Definition: DeclOpenMP.cpp:41
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
void setManglingNumber(const NamedDecl *ND, unsigned Number)
void setCompleteDefinition(bool V)
Definition: Decl.h:2920
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2403
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4114
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1067
bool CheckedICE
Whether we already checked whether this statement was an integral constant expression.
Definition: Decl.h:751
void VisitFriendTemplateDecl(FriendTemplateDecl *D)
void setLanguage(LanguageIDs L)
Set the language specified by this linkage specification.
Definition: DeclCXX.h:2566
Common * getCommonPtr() const
LambdaCaptureKind
The different capture forms in a lambda introducer.
Definition: Lambda.h:34
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
void setBlockMissingReturnType(bool val)
Definition: Decl.h:3588
void setLocStart(SourceLocation L)
Definition: Decl.h:453
static CXXRecordDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:128
RedeclarableResult VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D)
TODO: Unify with ClassTemplateSpecializationDecl version? May require unifying ClassTemplate(Partial)...
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:283
void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D)
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
CXXMethodDecl * getCanonicalDecl() override
Definition: DeclCXX.h:1804
Helper class that saves the current stream position and then restores it when destroyed.
Definition: ASTReader.h:2159
bool isTranslationUnit() const
Definition: DeclBase.h:1283
TagKind getTagKind() const
Definition: Decl.h:2930
static NamespaceDecl * getNamespace(const NestedNameSpecifier *X)
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD)
This declaration is definitely a definition.
Definition: Decl.h:1071
void Profile(llvm::FoldingSetNodeID &ID)
Definition: DeclTemplate.h:483
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
Definition: CharUnits.h:208
unsigned size() const
Definition: DeclTemplate.h:92
void setNumPositiveBits(unsigned Num)
Definition: Decl.h:3166
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:103
void setReturnType(QualType T)
Definition: DeclObjC.h:331
Declaration of a function specialization at template class scope.
static StaticAssertDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2314
void VisitLabelDecl(LabelDecl *LD)
static NamespaceDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2090
void setDeclImplementation(ImplementationControl ic)
Definition: DeclObjC.h:460
Describes a module or submodule.
Definition: Basic/Module.h:47
void setDefaultArgument(Expr *DefArg)
Set the default argument for this template parameter, and whether that default argument was inherited...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:947
A IndirectFieldDecl record.
Definition: ASTBitCodes.h:1147
static OMPCapturedExprDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclOpenMP.cpp:98
iterator end()
end - Returns an iterator that has 'finished'.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:399
Represents a C++ using-declaration.
Definition: DeclCXX.h:3039
void setUsingLoc(SourceLocation L)
Set the source location of the 'using' keyword.
Definition: DeclCXX.h:3072
bool isInheritingConstructor() const
Determine whether this is an implicit constructor synthesized to model a call to a constructor inheri...
Definition: DeclCXX.h:2380
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:160
void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:901
void setAccessControl(AccessControl ac)
Definition: DeclObjC.h:1886
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
static void attachLatestDecl(Decl *D, Decl *latest)
< Capturing the *this object by copy
Definition: Lambda.h:37
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:526
RedeclarableResult VisitVarDeclImpl(VarDecl *D)
DeclLink RedeclLink
Points to the next redeclaration in the chain.
Definition: Redeclarable.h:131
An AccessSpecDecl record.
Definition: ASTBitCodes.h:1112
void setAtLoc(SourceLocation L)
Definition: DeclObjC.h:774
A convenient class for passing around template argument information.
Definition: TemplateBase.h:523
uint32_t Offset
Definition: CacheTokens.cpp:44
uint32_t * LazySpecializations
If non-null, points to an array of specializations (including partial specializations) known ownly by...
A ConstructorUsingShadowDecl record.
Definition: ASTBitCodes.h:1090
A UsingDirecitveDecl record.
Definition: ASTBitCodes.h:1092
static UnresolvedUsingTypenameDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2296
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
We've merged the definition MergedDef into the existing definition Def.
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
void VisitCXXRecordDecl(CXXRecordDecl *D)
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
static ClassTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
void setSuperClass(ObjCInterfaceDecl *superCls)
Definition: DeclObjC.h:2591
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2569
void setHasObjectMember(bool val)
Definition: Decl.h:3326
static ObjCTypeParamList * create(ASTContext &ctx, SourceLocation lAngleLoc, ArrayRef< ObjCTypeParamDecl * > typeParams, SourceLocation rAngleLoc)
Create a new Objective-C type parameter list.
Definition: DeclObjC.cpp:1362
void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D)
void VisitMSPropertyDecl(MSPropertyDecl *FD)
static ObjCCategoryImplDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1992
void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2118
DeclID VisitTemplateDecl(TemplateDecl *D)
void setClassInterface(ObjCInterfaceDecl *D)
Definition: DeclObjC.h:2644
void setIdentifier(IdentifierInfo *II)
Definition: DeclObjC.h:2415
void setInstantiationOf(ClassTemplatePartialSpecializationDecl *PartialSpec, const TemplateArgumentList *TemplateArgs)
Note that this class template specialization is actually an instantiation of the given class template...
CXXRecordDecl * getCanonicalDecl() override
Definition: DeclCXX.h:654
llvm::iterator_range< MergedRedeclIterator< DeclT > > merged_redecls(DeclT *D)
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4194
void VisitCXXMethodDecl(CXXMethodDecl *D)
static TypeAliasDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4164
A ClassTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1121
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1968
void setNumNegativeBits(unsigned Num)
Definition: Decl.h:3183
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:2067
static bool isSameEntity(NamedDecl *X, NamedDecl *Y)
Determine whether the two declarations refer to the same entity.
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI)
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3625
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
Represents a linkage specification.
Definition: DeclCXX.h:2523
static ParmVarDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:2345
void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D)
detail::InMemoryDirectory::const_iterator I
void setInitVal(const llvm::APSInt &V)
Definition: Decl.h:2503
known_categories_range known_categories() const
Definition: DeclObjC.h:1593
QualType getCanonicalTypeInternal() const
Definition: Type.h:2001
QualType getType() const
Definition: Decl.h:599
void setInitExpr(Expr *E)
Definition: Decl.h:2502
void setLocStart(SourceLocation L)
Definition: Decl.h:2594
void setGetterCXXConstructor(Expr *getterCXXConstructor)
Definition: DeclObjC.h:2746
CXXConstructorDecl * getConstructor() const
Definition: DeclCXX.h:2174
void setInline(bool Inline)
Set whether this is an inline namespace declaration.
Definition: Decl.h:531
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2655
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
llvm::FoldingSetVector< FunctionTemplateSpecializationInfo > Specializations
The function template specializations for this function template, including explicit specializations ...
Definition: DeclTemplate.h:849
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void setVariadic(bool isVar)
Definition: DeclObjC.h:417
static TemplateTypeParmDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2701
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
RedeclarableResult VisitRedeclarable(Redeclarable< T > *D)
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition: Type.h:3304
void setHasDestructors(bool val)
Definition: DeclObjC.h:2558
void VisitObjCContainerDecl(ObjCContainerDecl *D)
static ObjCCompatibleAliasDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:2149
void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:646
void VisitParmVarDecl(ParmVarDecl *PD)
ASTContext * Context
void VisitLinkageSpecDecl(LinkageSpecDecl *D)
Decl * ReadDecl(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1701
void setIvarRBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2595
A StaticAssertDecl record.
Definition: ASTBitCodes.h:1141
llvm::FoldingSetVector< ClassTemplatePartialSpecializationDecl > PartialSpecializations
The class template partial specializations for this class template.
A VarTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1127
void VisitUsingShadowDecl(UsingShadowDecl *D)
void VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D)
TODO: Unify with ClassTemplatePartialSpecializationDecl version? May require unifying ClassTemplate(P...
void setNextIvar(ObjCIvarDecl *ivar)
Definition: DeclObjC.h:1884
void setSynthesize(bool synth)
Definition: DeclObjC.h:1894
void VisitFriendDecl(FriendDecl *D)
An ObjCTypeParamDecl record.
Definition: ASTBitCodes.h:1164
void VisitDecl(Decl *D)
A record containing CXXBaseSpecifiers.
Definition: ASTBitCodes.h:1143
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
void setType(QualType T, TypeSourceInfo *TSI)
Definition: DeclObjC.h:783
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2383
void setGetterMethodDecl(ObjCMethodDecl *gDecl)
Definition: DeclObjC.h:861
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:2927
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3456
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
Expr - This represents one expression.
Definition: Expr.h:105
A ObjCCategoryImplDecl record.
Definition: ASTBitCodes.h:1037
llvm::FoldingSetVector< VarTemplatePartialSpecializationDecl > PartialSpecializations
The variable template partial specializations for this variable template.
static LinkageSpecDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2034
DiagnosticBuilder Diag(unsigned DiagID)
Report a diagnostic.
Definition: ASTReader.cpp:8207
A ObjCPropertyImplDecl record.
Definition: ASTBitCodes.h:1045
QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a type from the current position in the given record, which was read from the given AST file...
Definition: ASTReader.h:1635
StateNode * Previous
Declaration of a template type parameter.
void setSetterMethodDecl(ObjCMethodDecl *gDecl)
Definition: DeclObjC.h:864
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2414
void setInit(Expr *I)
Definition: Decl.cpp:2081
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
A CXXConstructorDecl record.
Definition: ASTBitCodes.h:1104
void VisitTypedefDecl(TypedefDecl *TD)
void setContextParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:3688
void setAtEndRange(SourceRange atEnd)
Definition: DeclObjC.h:1043
void setRBraceLoc(SourceLocation L)
Definition: DeclCXX.h:2578
static DeclLink PreviousDeclLink(decl_type *D)
Definition: Redeclarable.h:112
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: Redeclarable.h:163
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a source range.
Definition: ASTReader.cpp:8144
A record containing CXXCtorInitializers.
Definition: ASTBitCodes.h:1145
A VarTemplateDecl record.
Definition: ASTBitCodes.h:1125
void setGetterName(Selector Sel)
Definition: DeclObjC.h:855
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
struct ExtInfo * ExtInfo
Definition: CGCleanup.h:260
void setMemberSpecialization()
Note that this member template is a specialization.
Definition: DeclTemplate.h:753
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
void setDefined(bool isDefined)
Definition: DeclObjC.h:425
void setCompleteDefinitionRequired(bool V=true)
Definition: Decl.h:2922
RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D)
Information about a module that has been loaded by the ASTReader.
A namespace alias, stored as a NamespaceAliasDecl*.
static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous, Decl *Canon)
A CXXDestructorDecl record.
Definition: ASTBitCodes.h:1108
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack...
Definition: ASTBitCodes.h:1150
static NamespaceAliasDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2148
static CXXConstructorDecl * CreateDeserialized(ASTContext &C, unsigned ID, bool InheritsConstructor)
Definition: DeclCXX.cpp:1821
StorageClass
Storage classes.
Definition: Specifiers.h:201
PragmaMSCommentKind
Definition: PragmaKinds.h:15
A NamespaceAliasDecl record.
Definition: ASTBitCodes.h:1084
void setTypename(bool TN)
Sets whether the using declaration has 'typename'.
Definition: DeclCXX.h:3094
Declaration of an alias template.
unsigned IsScopedUsingClassTag
IsScopedUsingClassTag - If this tag declaration is a scoped enum, then this is true if the scoped enu...
Definition: Decl.h:2768
void UpdateDecl(Decl *D, ModuleFile &ModuleFile, const RecordData &Record)
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition: Decl.h:2657
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
An ImplicitParamDecl record.
Definition: ASTBitCodes.h:1053
void setIvarRBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2298
class LLVM_ALIGNAS(8) TemplateSpecializationType unsigned NumArgs
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4154
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
Definition: Decl.cpp:1030
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2461
The result type of a method or function.
static UsingDirectiveDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2055
An EnumConstantDecl record.
Definition: ASTBitCodes.h:1021
static ObjCTypeParamDecl * CreateDeserialized(ASTContext &ctx, unsigned ID)
Definition: DeclObjC.cpp:1327
void VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
An ImportDecl recording a module import.
Definition: ASTBitCodes.h:1158
A ObjCCategoryDecl record.
Definition: ASTBitCodes.h:1035
static ObjCMethodDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:762
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:156
void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
void VisitObjCProtocolDecl(ObjCProtocolDecl *D)
A ObjCCompatibleAliasDecl record.
Definition: ASTBitCodes.h:1041
void VisitPragmaCommentDecl(PragmaCommentDecl *D)
ASTDeclReader(ASTReader &Reader, ASTReader::RecordLocation Loc, DeclID thisDeclID, SourceLocation ThisDeclLoc, const RecordData &Record, unsigned &Idx)
static TypeAliasTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty alias template node.
void setIsVariadic(bool value)
Definition: Decl.h:3533
static bool isSameQualifier(const NestedNameSpecifier *X, const NestedNameSpecifier *Y)
void VisitCXXConstructorDecl(CXXConstructorDecl *D)
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize)
Definition: Decl.cpp:3965
QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case...
Definition: Decl.h:613
void setColonLoc(SourceLocation CLoc)
Sets the location of the colon.
Definition: DeclCXX.h:124
An UnresolvedUsingValueDecl record.
Definition: ASTBitCodes.h:1094
Representation::iterator iterator
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:4344
void VisitDeclaratorDecl(DeclaratorDecl *DD)
static ObjCProtocolDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1796
static EnumConstantDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4088
Kind
static UsingShadowDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2173
void setIsConversionFromLambda(bool val)
Definition: Decl.h:3591
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
static void markIncompleteDeclChainImpl(Redeclarable< DeclT > *D)
static CXXDestructorDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:1965
Encodes a location in the source.
static EmptyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4206
static TemplateTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
const TemplateArgument * iterator
Definition: Type.h:4233
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:102
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1078
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:171
void setIvarLBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2296
void setBraceRange(SourceRange R)
Definition: Decl.h:2847
void setAtStartLoc(SourceLocation Loc)
Definition: DeclObjC.h:1037
void VisitEmptyDecl(EmptyDecl *D)
void setAnonymousNamespace(NamespaceDecl *D)
Definition: Decl.h:552
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
Definition: Basic/Module.h:214
void setFreeStanding(bool isFreeStanding=true)
Definition: Decl.h:2894
const std::string ID
void setObjCDeclQualifier(ObjCDeclQualifier QV)
Definition: DeclObjC.h:272
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
File is an implicitly-loaded module.
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:424
void mergeTemplatePattern(RedeclarableTemplateDecl *D, RedeclarableTemplateDecl *Existing, DeclID DsID, bool IsKeyDecl)
Merge together the pattern declarations from two template declarations.
void setPropertyAttributesAsWritten(PropertyAttributeKind PRVal)
Definition: DeclObjC.h:806
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3185
void setPosition(unsigned P)
void VisitObjCImplDecl(ObjCImplDecl *D)
bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
Definition: ASTReader.cpp:6339
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:3306
EnumDecl * getCanonicalDecl() override
Definition: Decl.h:3060
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
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:1397
A TemplateTypeParmDecl record.
Definition: ASTBitCodes.h:1133
Data that is common to all of the declarations of a given function template.
Definition: DeclTemplate.h:844
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2171
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:82
void setDeclName(DeclarationName N)
Set the name of this declaration.
Definition: Decl.h:261
static MSPropertyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2329
static ConstructorUsingShadowDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2196
Describes the categories of an Objective-C class.
Definition: ASTBitCodes.h:1543
void init(NamedDecl *templatedDecl, TemplateParameterList *templateParams)
Initialize the underlying templated declaration and template parameters.
Definition: DeclTemplate.h:388
void setPointOfInstantiation(SourceLocation Loc)
void setTagKind(TagKind TK)
Definition: Decl.h:2934
CommonBase * Common
Pointer to the common data shared by all declarations of this template.
Definition: DeclTemplate.h:703
static FunctionDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4044
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:699
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:2233
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:67
const unsigned int DECL_UPDATES
Record of updates for a declaration that was modified after being deserialized.
Definition: ASTBitCodes.h:999
void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
void VisitRecordDecl(RecordDecl *RD)
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1407
static T assert_cast(T t)
"Cast" to type T, asserting if we don't have an implicit conversion.
static VarTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty variable template node.
A NamespaceDecl record.
Definition: ASTBitCodes.h:1082
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3327
uint32_t BitOffset
Offset in the AST file.
Definition: ASTBitCodes.h:191
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:542
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:563
unsigned varlist_size() const
Definition: DeclOpenMP.h:74
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3728
void VisitValueDecl(ValueDecl *VD)
A ObjCProtocolDecl record.
Definition: ASTBitCodes.h:1029
void setDeclaredWithTypename(bool withTypename)
Set whether this template type parameter was declared with the 'typename' or 'class' keyword...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
void setSetterCXXAssignment(Expr *setterCXXAssignment)
Definition: DeclObjC.h:2753
void VisitEnumDecl(EnumDecl *ED)
static TypedefDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4152
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2609
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
void setPropertyDecl(ObjCPropertyDecl *Prop)
Definition: DeclObjC.h:2715
A CXXConversionDecl record.
Definition: ASTBitCodes.h:1110
TagTypeKind
The kind of a tag type.
Definition: Type.h:4342
ObjCTypeParamList * ReadObjCTypeParamList()
void VisitCXXConversionDecl(CXXConversionDecl *D)
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:2719
void setBody(CompoundStmt *B)
Definition: Decl.h:3537
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2076
static CXXConversionDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:1996
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block.
static ClassScopeFunctionSpecializationDecl * CreateDeserialized(ASTContext &Context, unsigned ID)
static bool isSameTemplateParameterList(const TemplateParameterList *X, const TemplateParameterList *Y)
Determine whether two template parameter lists are similar enough that they may be used in declaratio...
void setHasVolatileMember(bool val)
Definition: Decl.h:3329
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1135
static ClassTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty class template node.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:330
void VisitFunctionDecl(FunctionDecl *FD)
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:312
File is an explicitly-loaded module.
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2521
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
A ClassTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1123
void setUsingLoc(SourceLocation L)
Set the source location of the 'using' keyword.
Definition: DeclCXX.h:3214
DeclCode
Record codes for each kind of declaration.
Definition: ASTBitCodes.h:1011
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
unsigned IsScoped
IsScoped - True if this tag declaration is a scoped enumeration.
Definition: Decl.h:2763
RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D)
void setIvarList(ObjCIvarDecl *ivar)
Definition: DeclObjC.h:1393
static VarTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3268
A ClassScopeFunctionSpecializationDecl record a class scope function specialization.
Definition: ASTBitCodes.h:1156
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:532
void VisitObjCMethodDecl(ObjCMethodDecl *D)
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:3230
A LinkageSpecDecl record.
Definition: ASTBitCodes.h:1098
RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD)
static NonTypeTemplateParmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
ParmVarDeclBitfields ParmVarDeclBits
Definition: Decl.h:907
static ObjCCategoryDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1947
void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
void VisitObjCImplementationDecl(ObjCImplementationDecl *D)
EnumDecl - Represents an enum.
Definition: Decl.h:3013
void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D)
detail::InMemoryDirectory::const_iterator E
for(auto typeArg:T->getTypeArgsAsWritten())
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:141
static void forAllLaterRedecls(DeclT *D, Fn F)
void setExternLoc(SourceLocation L)
Definition: DeclCXX.h:2577
static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From, Decl *ToD)
Inherit the default template argument from From to To.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the 'template' keyword, stored as a Type*.
static FriendTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const
Read a source location from raw form.
Definition: ASTReader.h:2013
uint32_t * LazySpecializations
If non-null, points to an array of specializations (including partial specializations) known only by ...
static LabelDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:3992
All of the names in this module are visible.
Definition: Basic/Module.h:210
Capturing variable-length array type.
Definition: Lambda.h:39
A PragmaCommentDecl record.
Definition: ASTBitCodes.h:1168
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope...
Definition: ASTReader.cpp:8743
static ObjCAtDefsFieldDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1761
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2461
Common * getCommonPtr() const
Definition: DeclTemplate.h:876
void VisitObjCPropertyDecl(ObjCPropertyDecl *D)
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Definition: Redeclarable.h:257
NonParmVarDeclBitfields NonParmVarDeclBits
Definition: Decl.h:908
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
void setInstantiatedFromMemberTemplate(RedeclarableTemplateDecl *TD)
Definition: DeclTemplate.h:799
void setHasNonZeroConstructors(bool val)
Definition: DeclObjC.h:2553
static ClassTemplatePartialSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2532
static ImplicitParamDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4023
static RecordDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
Definition: Decl.cpp:3740
void ReadTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument array.
Definition: ASTReader.cpp:7903
void setCombiner(Expr *E)
Set combiner expression for the declare reduction construct.
Definition: DeclOpenMP.h:139
void setInitializer(Expr *E)
Set initializer expression for the declare reduction construct.
Definition: DeclOpenMP.h:146
static CXXMethodDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:1551
NestedNameSpecifier * getQualifier() const
Definition: Type.h:4579
RedeclarableTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:723
static EnumDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:3639
void setSetterName(Selector Sel)
Definition: DeclObjC.h:858
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1534
void VisitNamespaceDecl(NamespaceDecl *D)
static FunctionTemplateDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create an empty function template node.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1815
The "class" keyword.
Definition: Type.h:4350
Capturing the *this object by reference.
Definition: Lambda.h:35
void VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:686
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1405
void setSignatureAsWritten(TypeSourceInfo *Sig)
Definition: Decl.h:3539
void setPromotionType(QualType T)
Set the promotion type.
Definition: Decl.h:3132
static bool isSameTemplateParameter(const NamedDecl *X, const NamedDecl *Y)
Determine whether two template parameters are similar enough that they may be used in declarations of...
unsigned IsFixed
IsFixed - True if this is an enumeration with fixed underlying type.
Definition: Decl.h:2772
void setAsmString(StringLiteral *Asm)
Definition: Decl.h:3446
static VarTemplateSpecializationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
void setRParenLoc(SourceLocation L)
Definition: Decl.h:3439
A template argument list.
Definition: DeclTemplate.h:173
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...
Definition: ASTContext.cpp:880
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:12171
static bool isConsumerInterestedIn(Decl *D, bool HasBody)
Determine whether the consumer will be interested in seeing this declaration (via HandleTopLevelDecl)...
static FieldDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:3452
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
void VisitCapturedDecl(CapturedDecl *CD)
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:1916
static Decl * getMostRecentDeclImpl(Redeclarable< DeclT > *D)
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:358
FormatToken * Current
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
static OMPDeclareReductionDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Create deserialized declare reduction node.
Definition: DeclOpenMP.cpp:70
static ObjCImplementationDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:2105
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2281
void setInstanceMethod(bool isInst)
Definition: DeclObjC.h:415
void SetRelatedResultType(bool RRT=true)
Note whether this method has a related result type.
Definition: DeclObjC.h:279
void setClassInterface(ObjCInterfaceDecl *IFace)
Definition: DeclObjC.cpp:2015
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1849
bool operator!=(CanQual< T > x, CanQual< U > y)
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:323
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:500
A ObjCImplementationDecl record.
Definition: ASTBitCodes.h:1039
Capturing by reference.
Definition: Lambda.h:38
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source...
void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
void setReturnTypeSourceInfo(TypeSourceInfo *TInfo)
Definition: DeclObjC.h:345
A ObjCAtDefsFieldDecl record.
Definition: ASTBitCodes.h:1033
Declaration of a class template.
void setIvarLBraceLoc(SourceLocation Loc)
Definition: DeclObjC.h:2593
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:610
void VisitAccessSpecDecl(AccessSpecDecl *D)
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:353
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
void setPropertyAttributes(PropertyAttributeKind PRVal)
Definition: DeclObjC.h:795
static BlockDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4054
const unsigned int LOCAL_REDECLARATIONS
Record code for a list of local redeclarations of a declaration.
Definition: ASTBitCodes.h:1003
A TypeAliasDecl record.
Definition: ASTBitCodes.h:1015
void VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D)
uint32_t * LazySpecializations
If non-null, points to an array of specializations known only by their external declaration IDs...
Definition: DeclTemplate.h:865
static DeclID * newDeclIDList(ASTContext &Context, DeclID *Old, SmallVectorImpl< DeclID > &IDs)
void VisitBlockDecl(BlockDecl *BD)
llvm::FoldingSetVector< VarTemplateSpecializationDecl > Specializations
The variable template specializations for this variable template, including explicit specializations ...
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:3072
void ReadAttributes(ModuleFile &F, AttrVec &Attrs, const RecordData &Record, unsigned &Idx)
Reads attributes from the current stream position.
void VisitIndirectFieldDecl(IndirectFieldDecl *FD)
bool isIncompleteArrayType() const
Definition: Type.h:5527
Common * getCommonPtr() const
VarDeclBitfields VarDeclBits
Definition: Decl.h:906
llvm::FoldingSetVector< ClassTemplateSpecializationDecl > Specializations
The class template specializations for this class template, including explicit specializations and in...
virtual CommonBase * newCommon(ASTContext &C) const =0
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:80
static ObjCInterfaceDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:1400
void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D)
QualType getElementType() const
Definition: Type.h:2490
SourceLocation getLocation() const
Definition: ASTBitCodes.h:200
A FunctionTemplateDecl record.
Definition: ASTBitCodes.h:1131
std::pair< uint64_t, uint64_t > VisitDeclContext(DeclContext *DC)
static ObjCPropertyImplDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:2200
ModuleFile * getOwningModuleFile(const Decl *D)
Retrieve the module file that owns the given declaration, or NULL if the declaration is not from a mo...
Definition: ASTReader.cpp:6349
A TypeAliasTemplateDecl record.
Definition: ASTBitCodes.h:1139
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3394
void setAtLoc(SourceLocation Loc)
Definition: DeclObjC.h:2710
void VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:80
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
Definition: Decl.cpp:3888
A trivial tuple used to represent a source range.
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition: Decl.h:3149
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
void VisitVarTemplateDecl(VarTemplateDecl *D)
TODO: Unify with ClassTemplateDecl version? May require unifying ClassTemplateDecl and VarTemplateDec...
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:2654
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:94
Represents a C++ namespace alias.
Definition: DeclCXX.h:2718
static UsingDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2244
serialization::DeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, serialization::DeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
Definition: ASTReader.cpp:6477
Declaration of a friend template.
Represents C++ using-directive.
Definition: DeclCXX.h:2615
Represents a #pragma detect_mismatch line.
Definition: Decl.h:143
static ObjCPropertyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclObjC.cpp:2172
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:545
The global specifier '::'. There is no stored value.
void VisitTranslationUnitDecl(TranslationUnitDecl *TU)
void setType(QualType newType)
Definition: Decl.h:600
void setCmdDecl(ImplicitParamDecl *CD)
Definition: DeclObjC.h:409
This represents '#pragma omp threadprivate ...' directive.
Definition: DeclOpenMP.h:39
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2380
Declaration of a template function.
Definition: DeclTemplate.h:838
iterator - Iterate over the decls of a specified declaration name.
void setTargetDecl(NamedDecl *ND)
Sets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:2893
void setPropertyIvarDecl(ObjCIvarDecl *Ivar)
Definition: DeclObjC.h:874
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:187
Attr - This represents one attribute.
Definition: Attr.h:45
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID...
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2835
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2626
bool isHidden() const
Determine whether this declaration is hidden from name lookup.
Definition: Decl.h:305
Structure used to store a statement, the constant value to which it was evaluated (if any)...
Definition: Decl.h:739
void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D)
TemplatedKind
The kind of templated function a FunctionDecl can be.
Definition: Decl.h:1565