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