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