clang  14.0.0git
ASTWriterDecl.cpp
Go to the documentation of this file.
1 //===--- ASTWriterDecl.cpp - Declaration Serialization --------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements serialization for Declarations.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "ASTCommon.h"
14 #include "clang/AST/Attr.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclTemplate.h"
17 #include "clang/AST/DeclVisitor.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/OpenMPClause.h"
24 #include "llvm/Bitstream/BitstreamWriter.h"
25 #include "llvm/Support/ErrorHandling.h"
26 using namespace clang;
27 using namespace serialization;
28 
29 //===----------------------------------------------------------------------===//
30 // Declaration serialization
31 //===----------------------------------------------------------------------===//
32 
33 namespace clang {
34  class ASTDeclWriter : public DeclVisitor<ASTDeclWriter, void> {
35  ASTWriter &Writer;
36  ASTContext &Context;
37  ASTRecordWriter Record;
38 
40  unsigned AbbrevToUse;
41 
42  public:
43  ASTDeclWriter(ASTWriter &Writer, ASTContext &Context,
45  : Writer(Writer), Context(Context), Record(Writer, Record),
46  Code((serialization::DeclCode)0), AbbrevToUse(0) {}
47 
48  uint64_t Emit(Decl *D) {
49  if (!Code)
50  llvm::report_fatal_error(StringRef("unexpected declaration kind '") +
51  D->getDeclKindName() + "'");
52  return Record.Emit(Code, AbbrevToUse);
53  }
54 
55  void Visit(Decl *D);
56 
57  void VisitDecl(Decl *D);
58  void VisitPragmaCommentDecl(PragmaCommentDecl *D);
59  void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
60  void VisitTranslationUnitDecl(TranslationUnitDecl *D);
61  void VisitNamedDecl(NamedDecl *D);
62  void VisitLabelDecl(LabelDecl *LD);
63  void VisitNamespaceDecl(NamespaceDecl *D);
64  void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
65  void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
66  void VisitTypeDecl(TypeDecl *D);
67  void VisitTypedefNameDecl(TypedefNameDecl *D);
68  void VisitTypedefDecl(TypedefDecl *D);
69  void VisitTypeAliasDecl(TypeAliasDecl *D);
70  void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
71  void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D);
72  void VisitTagDecl(TagDecl *D);
73  void VisitEnumDecl(EnumDecl *D);
74  void VisitRecordDecl(RecordDecl *D);
75  void VisitCXXRecordDecl(CXXRecordDecl *D);
76  void VisitClassTemplateSpecializationDecl(
78  void VisitClassTemplatePartialSpecializationDecl(
80  void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
81  void VisitVarTemplatePartialSpecializationDecl(
83  void VisitClassScopeFunctionSpecializationDecl(
85  void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
86  void VisitValueDecl(ValueDecl *D);
87  void VisitEnumConstantDecl(EnumConstantDecl *D);
88  void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
89  void VisitDeclaratorDecl(DeclaratorDecl *D);
90  void VisitFunctionDecl(FunctionDecl *D);
91  void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
92  void VisitCXXMethodDecl(CXXMethodDecl *D);
93  void VisitCXXConstructorDecl(CXXConstructorDecl *D);
94  void VisitCXXDestructorDecl(CXXDestructorDecl *D);
95  void VisitCXXConversionDecl(CXXConversionDecl *D);
96  void VisitFieldDecl(FieldDecl *D);
97  void VisitMSPropertyDecl(MSPropertyDecl *D);
98  void VisitMSGuidDecl(MSGuidDecl *D);
99  void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D);
100  void VisitIndirectFieldDecl(IndirectFieldDecl *D);
101  void VisitVarDecl(VarDecl *D);
102  void VisitImplicitParamDecl(ImplicitParamDecl *D);
103  void VisitParmVarDecl(ParmVarDecl *D);
104  void VisitDecompositionDecl(DecompositionDecl *D);
105  void VisitBindingDecl(BindingDecl *D);
106  void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
107  void VisitTemplateDecl(TemplateDecl *D);
108  void VisitConceptDecl(ConceptDecl *D);
109  void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D);
110  void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
111  void VisitClassTemplateDecl(ClassTemplateDecl *D);
112  void VisitVarTemplateDecl(VarTemplateDecl *D);
113  void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
114  void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
115  void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
116  void VisitUsingDecl(UsingDecl *D);
117  void VisitUsingEnumDecl(UsingEnumDecl *D);
118  void VisitUsingPackDecl(UsingPackDecl *D);
119  void VisitUsingShadowDecl(UsingShadowDecl *D);
120  void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D);
121  void VisitLinkageSpecDecl(LinkageSpecDecl *D);
122  void VisitExportDecl(ExportDecl *D);
123  void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
124  void VisitImportDecl(ImportDecl *D);
125  void VisitAccessSpecDecl(AccessSpecDecl *D);
126  void VisitFriendDecl(FriendDecl *D);
127  void VisitFriendTemplateDecl(FriendTemplateDecl *D);
128  void VisitStaticAssertDecl(StaticAssertDecl *D);
129  void VisitBlockDecl(BlockDecl *D);
130  void VisitCapturedDecl(CapturedDecl *D);
131  void VisitEmptyDecl(EmptyDecl *D);
132  void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
133 
134  void VisitDeclContext(DeclContext *DC);
135  template <typename T> void VisitRedeclarable(Redeclarable<T> *D);
136 
137 
138  // FIXME: Put in the same order is DeclNodes.td?
139  void VisitObjCMethodDecl(ObjCMethodDecl *D);
140  void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
141  void VisitObjCContainerDecl(ObjCContainerDecl *D);
142  void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
143  void VisitObjCIvarDecl(ObjCIvarDecl *D);
144  void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
145  void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
146  void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
147  void VisitObjCImplDecl(ObjCImplDecl *D);
148  void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
149  void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
150  void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
151  void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
152  void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
153  void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
154  void VisitOMPAllocateDecl(OMPAllocateDecl *D);
155  void VisitOMPRequiresDecl(OMPRequiresDecl *D);
156  void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
157  void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
158  void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
159 
160  /// Add an Objective-C type parameter list to the given record.
162  // Empty type parameter list.
163  if (!typeParams) {
164  Record.push_back(0);
165  return;
166  }
167 
168  Record.push_back(typeParams->size());
169  for (auto typeParam : *typeParams) {
170  Record.AddDeclRef(typeParam);
171  }
172  Record.AddSourceLocation(typeParams->getLAngleLoc());
173  Record.AddSourceLocation(typeParams->getRAngleLoc());
174  }
175 
176  /// Add to the record the first declaration from each module file that
177  /// provides a declaration of D. The intent is to provide a sufficient
178  /// set such that reloading this set will load all current redeclarations.
179  void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal) {
180  llvm::MapVector<ModuleFile*, const Decl*> Firsts;
181  // FIXME: We can skip entries that we know are implied by others.
182  for (const Decl *R = D->getMostRecentDecl(); R; R = R->getPreviousDecl()) {
183  if (R->isFromASTFile())
184  Firsts[Writer.Chain->getOwningModuleFile(R)] = R;
185  else if (IncludeLocal)
186  Firsts[nullptr] = R;
187  }
188  for (const auto &F : Firsts)
189  Record.AddDeclRef(F.second);
190  }
191 
192  /// Get the specialization decl from an entry in the specialization list.
193  template <typename EntryType>
195  getSpecializationDecl(EntryType &T) {
197  }
198 
199  /// Get the list of partial specializations from a template's common ptr.
200  template<typename T>
201  decltype(T::PartialSpecializations) &getPartialSpecializations(T *Common) {
202  return Common->PartialSpecializations;
203  }
205  return None;
206  }
207 
208  template<typename DeclTy>
210  auto *Common = D->getCommonPtr();
211 
212  // If we have any lazy specializations, and the external AST source is
213  // our chained AST reader, we can just write out the DeclIDs. Otherwise,
214  // we need to resolve them to actual declarations.
215  if (Writer.Chain != Writer.Context->getExternalSource() &&
216  Common->LazySpecializations) {
217  D->LoadLazySpecializations();
218  assert(!Common->LazySpecializations);
219  }
220 
221  ArrayRef<DeclID> LazySpecializations;
222  if (auto *LS = Common->LazySpecializations)
223  LazySpecializations = llvm::makeArrayRef(LS + 1, LS[0]);
224 
225  // Add a slot to the record for the number of specializations.
226  unsigned I = Record.size();
227  Record.push_back(0);
228 
229  // AddFirstDeclFromEachModule might trigger deserialization, invalidating
230  // *Specializations iterators.
232  for (auto &Entry : Common->Specializations)
233  Specs.push_back(getSpecializationDecl(Entry));
234  for (auto &Entry : getPartialSpecializations(Common))
235  Specs.push_back(getSpecializationDecl(Entry));
236 
237  for (auto *D : Specs) {
238  assert(D->isCanonicalDecl() && "non-canonical decl in set");
239  AddFirstDeclFromEachModule(D, /*IncludeLocal*/true);
240  }
241  Record.append(LazySpecializations.begin(), LazySpecializations.end());
242 
243  // Update the size entry we added earlier.
244  Record[I] = Record.size() - I - 1;
245  }
246 
247  /// Ensure that this template specialization is associated with the specified
248  /// template on reload.
249  void RegisterTemplateSpecialization(const Decl *Template,
250  const Decl *Specialization) {
251  Template = Template->getCanonicalDecl();
252 
253  // If the canonical template is local, we'll write out this specialization
254  // when we emit it.
255  // FIXME: We can do the same thing if there is any local declaration of
256  // the template, to avoid emitting an update record.
257  if (!Template->isFromASTFile())
258  return;
259 
260  // We only need to associate the first local declaration of the
261  // specialization. The other declarations will get pulled in by it.
263  return;
264 
265  Writer.DeclUpdates[Template].push_back(ASTWriter::DeclUpdate(
267  }
268  };
269 }
270 
273 
274  // Source locations require array (variable-length) abbreviations. The
275  // abbreviation infrastructure requires that arrays are encoded last, so
276  // we handle it here in the case of those classes derived from DeclaratorDecl
277  if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
278  if (auto *TInfo = DD->getTypeSourceInfo())
279  Record.AddTypeLoc(TInfo->getTypeLoc());
280  }
281 
282  // Handle FunctionDecl's body here and write it after all other Stmts/Exprs
283  // have been written. We want it last because we will not read it back when
284  // retrieving it from the AST, we'll just lazily set the offset.
285  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
286  Record.push_back(FD->doesThisDeclarationHaveABody());
287  if (FD->doesThisDeclarationHaveABody())
288  Record.AddFunctionDefinition(FD);
289  }
290 
291  // If this declaration is also a DeclContext, write blocks for the
292  // declarations that lexically stored inside its context and those
293  // declarations that are visible from its context.
294  if (DeclContext *DC = dyn_cast<DeclContext>(D))
295  VisitDeclContext(DC);
296 }
297 
299  Record.AddDeclRef(cast_or_null<Decl>(D->getDeclContext()));
300  if (D->getDeclContext() != D->getLexicalDeclContext())
301  Record.AddDeclRef(cast_or_null<Decl>(D->getLexicalDeclContext()));
302  else
303  Record.push_back(0);
304  Record.push_back(D->isInvalidDecl());
305  Record.push_back(D->hasAttrs());
306  if (D->hasAttrs())
307  Record.AddAttributes(D->getAttrs());
308  Record.push_back(D->isImplicit());
309  Record.push_back(D->isUsed(false));
310  Record.push_back(D->isReferenced());
311  Record.push_back(D->isTopLevelDeclInObjCContainer());
312  Record.push_back(D->getAccess());
313  Record.push_back(D->isModulePrivate());
314  Record.push_back(Writer.getSubmoduleID(D->getOwningModule()));
315 
316  // If this declaration injected a name into a context different from its
317  // lexical context, and that context is an imported namespace, we need to
318  // update its visible declarations to include this name.
319  //
320  // This happens when we instantiate a class with a friend declaration or a
321  // function with a local extern declaration, for instance.
322  //
323  // FIXME: Can we handle this in AddedVisibleDecl instead?
324  if (D->isOutOfLine()) {
325  auto *DC = D->getDeclContext();
326  while (auto *NS = dyn_cast<NamespaceDecl>(DC->getRedeclContext())) {
327  if (!NS->isFromASTFile())
328  break;
329  Writer.UpdatedDeclContexts.insert(NS->getPrimaryContext());
330  if (!NS->isInlineNamespace())
331  break;
332  DC = NS->getParent();
333  }
334  }
335 }
336 
338  StringRef Arg = D->getArg();
339  Record.push_back(Arg.size());
340  VisitDecl(D);
341  Record.AddSourceLocation(D->getBeginLoc());
342  Record.push_back(D->getCommentKind());
343  Record.AddString(Arg);
345 }
346 
349  StringRef Name = D->getName();
350  StringRef Value = D->getValue();
351  Record.push_back(Name.size() + 1 + Value.size());
352  VisitDecl(D);
353  Record.AddSourceLocation(D->getBeginLoc());
354  Record.AddString(Name);
355  Record.AddString(Value);
357 }
358 
360  llvm_unreachable("Translation units aren't directly serialized");
361 }
362 
364  VisitDecl(D);
365  Record.AddDeclarationName(D->getDeclName());
366  Record.push_back(needsAnonymousDeclarationNumber(D)
367  ? Writer.getAnonymousDeclarationNumber(D)
368  : 0);
369 }
370 
372  VisitNamedDecl(D);
373  Record.AddSourceLocation(D->getBeginLoc());
374  Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
375 }
376 
378  VisitRedeclarable(D);
379  VisitTypeDecl(D);
380  Record.AddTypeSourceInfo(D->getTypeSourceInfo());
381  Record.push_back(D->isModed());
382  if (D->isModed())
383  Record.AddTypeRef(D->getUnderlyingType());
384  Record.AddDeclRef(D->getAnonDeclWithTypedefName(false));
385 }
386 
388  VisitTypedefNameDecl(D);
389  if (D->getDeclContext() == D->getLexicalDeclContext() &&
390  !D->hasAttrs() &&
391  !D->isImplicit() &&
392  D->getFirstDecl() == D->getMostRecentDecl() &&
393  !D->isInvalidDecl() &&
395  !D->isModulePrivate() &&
398  AbbrevToUse = Writer.getDeclTypedefAbbrev();
399 
401 }
402 
404  VisitTypedefNameDecl(D);
405  Record.AddDeclRef(D->getDescribedAliasTemplate());
407 }
408 
410  VisitRedeclarable(D);
411  VisitTypeDecl(D);
412  Record.push_back(D->getIdentifierNamespace());
413  Record.push_back((unsigned)D->getTagKind()); // FIXME: stable encoding
414  if (!isa<CXXRecordDecl>(D))
415  Record.push_back(D->isCompleteDefinition());
416  Record.push_back(D->isEmbeddedInDeclarator());
417  Record.push_back(D->isFreeStanding());
418  Record.push_back(D->isCompleteDefinitionRequired());
419  Record.AddSourceRange(D->getBraceRange());
420 
421  if (D->hasExtInfo()) {
422  Record.push_back(1);
423  Record.AddQualifierInfo(*D->getExtInfo());
424  } else if (auto *TD = D->getTypedefNameForAnonDecl()) {
425  Record.push_back(2);
426  Record.AddDeclRef(TD);
427  Record.AddIdentifierRef(TD->getDeclName().getAsIdentifierInfo());
428  } else {
429  Record.push_back(0);
430  }
431 }
432 
434  VisitTagDecl(D);
435  Record.AddTypeSourceInfo(D->getIntegerTypeSourceInfo());
436  if (!D->getIntegerTypeSourceInfo())
437  Record.AddTypeRef(D->getIntegerType());
438  Record.AddTypeRef(D->getPromotionType());
439  Record.push_back(D->getNumPositiveBits());
440  Record.push_back(D->getNumNegativeBits());
441  Record.push_back(D->isScoped());
442  Record.push_back(D->isScopedUsingClassTag());
443  Record.push_back(D->isFixed());
444  Record.push_back(D->getODRHash());
445 
446  if (MemberSpecializationInfo *MemberInfo = D->getMemberSpecializationInfo()) {
447  Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
448  Record.push_back(MemberInfo->getTemplateSpecializationKind());
449  Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
450  } else {
451  Record.AddDeclRef(nullptr);
452  }
453 
454  if (D->getDeclContext() == D->getLexicalDeclContext() &&
455  !D->hasAttrs() &&
456  !D->isImplicit() &&
457  !D->isUsed(false) &&
458  !D->hasExtInfo() &&
460  D->getFirstDecl() == D->getMostRecentDecl() &&
461  !D->isInvalidDecl() &&
462  !D->isReferenced() &&
464  D->getAccess() == AS_none &&
465  !D->isModulePrivate() &&
467  !D->getIntegerTypeSourceInfo() &&
471  AbbrevToUse = Writer.getDeclEnumAbbrev();
472 
474 }
475 
477  VisitTagDecl(D);
478  Record.push_back(D->hasFlexibleArrayMember());
479  Record.push_back(D->isAnonymousStructOrUnion());
480  Record.push_back(D->hasObjectMember());
481  Record.push_back(D->hasVolatileMember());
482  Record.push_back(D->isNonTrivialToPrimitiveDefaultInitialize());
483  Record.push_back(D->isNonTrivialToPrimitiveCopy());
484  Record.push_back(D->isNonTrivialToPrimitiveDestroy());
486  Record.push_back(D->hasNonTrivialToPrimitiveDestructCUnion());
487  Record.push_back(D->hasNonTrivialToPrimitiveCopyCUnion());
488  Record.push_back(D->isParamDestroyedInCallee());
489  Record.push_back(D->getArgPassingRestrictions());
490 
491  if (D->getDeclContext() == D->getLexicalDeclContext() &&
492  !D->hasAttrs() &&
493  !D->isImplicit() &&
494  !D->isUsed(false) &&
495  !D->hasExtInfo() &&
497  D->getFirstDecl() == D->getMostRecentDecl() &&
498  !D->isInvalidDecl() &&
499  !D->isReferenced() &&
501  D->getAccess() == AS_none &&
502  !D->isModulePrivate() &&
506  AbbrevToUse = Writer.getDeclRecordAbbrev();
507 
509 }
510 
512  VisitNamedDecl(D);
513  Record.AddTypeRef(D->getType());
514 }
515 
517  VisitValueDecl(D);
518  Record.push_back(D->getInitExpr()? 1 : 0);
519  if (D->getInitExpr())
520  Record.AddStmt(D->getInitExpr());
521  Record.AddAPSInt(D->getInitVal());
522 
524 }
525 
527  VisitValueDecl(D);
528  Record.AddSourceLocation(D->getInnerLocStart());
529  Record.push_back(D->hasExtInfo());
530  if (D->hasExtInfo()) {
531  DeclaratorDecl::ExtInfo *Info = D->getExtInfo();
532  Record.AddQualifierInfo(*Info);
533  Record.AddStmt(Info->TrailingRequiresClause);
534  }
535  // The location information is deferred until the end of the record.
536  Record.AddTypeRef(D->getTypeSourceInfo() ? D->getTypeSourceInfo()->getType()
537  : QualType());
538 }
539 
541  VisitRedeclarable(D);
542  VisitDeclaratorDecl(D);
543  Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
544  Record.push_back(D->getIdentifierNamespace());
545 
546  // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
547  // after everything else is written.
548  Record.push_back(static_cast<int>(D->getStorageClass())); // FIXME: stable encoding
549  Record.push_back(D->isInlineSpecified());
550  Record.push_back(D->isInlined());
551  Record.push_back(D->isVirtualAsWritten());
552  Record.push_back(D->isPure());
553  Record.push_back(D->hasInheritedPrototype());
554  Record.push_back(D->hasWrittenPrototype());
555  Record.push_back(D->isDeletedBit());
556  Record.push_back(D->isTrivial());
557  Record.push_back(D->isTrivialForCall());
558  Record.push_back(D->isDefaulted());
559  Record.push_back(D->isExplicitlyDefaulted());
560  Record.push_back(D->hasImplicitReturnZero());
561  Record.push_back(static_cast<uint64_t>(D->getConstexprKind()));
562  Record.push_back(D->usesSEHTry());
563  Record.push_back(D->hasSkippedBody());
564  Record.push_back(D->isMultiVersion());
565  Record.push_back(D->isLateTemplateParsed());
566  Record.push_back(D->getLinkageInternal());
567  Record.AddSourceLocation(D->getEndLoc());
568 
569  Record.push_back(D->getODRHash());
570 
571  if (D->isDefaulted()) {
572  if (auto *FDI = D->getDefaultedFunctionInfo()) {
573  Record.push_back(FDI->getUnqualifiedLookups().size());
574  for (DeclAccessPair P : FDI->getUnqualifiedLookups()) {
575  Record.AddDeclRef(P.getDecl());
576  Record.push_back(P.getAccess());
577  }
578  } else {
579  Record.push_back(0);
580  }
581  }
582 
583  Record.push_back(D->getTemplatedKind());
584  switch (D->getTemplatedKind()) {
586  break;
588  Record.AddDeclRef(D->getDescribedFunctionTemplate());
589  break;
592  Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
593  Record.push_back(MemberInfo->getTemplateSpecializationKind());
594  Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
595  break;
596  }
599  FTSInfo = D->getTemplateSpecializationInfo();
600 
601  RegisterTemplateSpecialization(FTSInfo->getTemplate(), D);
602 
603  Record.AddDeclRef(FTSInfo->getTemplate());
604  Record.push_back(FTSInfo->getTemplateSpecializationKind());
605 
606  // Template arguments.
607  Record.AddTemplateArgumentList(FTSInfo->TemplateArguments);
608 
609  // Template args as written.
610  Record.push_back(FTSInfo->TemplateArgumentsAsWritten != nullptr);
611  if (FTSInfo->TemplateArgumentsAsWritten) {
612  Record.push_back(FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs);
613  for (int i=0, e = FTSInfo->TemplateArgumentsAsWritten->NumTemplateArgs;
614  i!=e; ++i)
615  Record.AddTemplateArgumentLoc(
616  (*FTSInfo->TemplateArgumentsAsWritten)[i]);
617  Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->LAngleLoc);
618  Record.AddSourceLocation(FTSInfo->TemplateArgumentsAsWritten->RAngleLoc);
619  }
620 
621  Record.AddSourceLocation(FTSInfo->getPointOfInstantiation());
622 
623  if (MemberSpecializationInfo *MemberInfo =
624  FTSInfo->getMemberSpecializationInfo()) {
625  Record.push_back(1);
626  Record.AddDeclRef(MemberInfo->getInstantiatedFrom());
627  Record.push_back(MemberInfo->getTemplateSpecializationKind());
628  Record.AddSourceLocation(MemberInfo->getPointOfInstantiation());
629  } else {
630  Record.push_back(0);
631  }
632 
633  if (D->isCanonicalDecl()) {
634  // Write the template that contains the specializations set. We will
635  // add a FunctionTemplateSpecializationInfo to it when reading.
636  Record.AddDeclRef(FTSInfo->getTemplate()->getCanonicalDecl());
637  }
638  break;
639  }
642  DFTSInfo = D->getDependentSpecializationInfo();
643 
644  // Templates.
645  Record.push_back(DFTSInfo->getNumTemplates());
646  for (int i=0, e = DFTSInfo->getNumTemplates(); i != e; ++i)
647  Record.AddDeclRef(DFTSInfo->getTemplate(i));
648 
649  // Templates args.
650  Record.push_back(DFTSInfo->getNumTemplateArgs());
651  for (int i=0, e = DFTSInfo->getNumTemplateArgs(); i != e; ++i)
652  Record.AddTemplateArgumentLoc(DFTSInfo->getTemplateArg(i));
653  Record.AddSourceLocation(DFTSInfo->getLAngleLoc());
654  Record.AddSourceLocation(DFTSInfo->getRAngleLoc());
655  break;
656  }
657  }
658 
659  Record.push_back(D->param_size());
660  for (auto P : D->parameters())
661  Record.AddDeclRef(P);
663 }
664 
666  ASTRecordWriter &Record) {
667  uint64_t Kind = static_cast<uint64_t>(ES.getKind());
668  Kind = Kind << 1 | static_cast<bool>(ES.getExpr());
669  Record.push_back(Kind);
670  if (ES.getExpr()) {
671  Record.AddStmt(ES.getExpr());
672  }
673 }
674 
677  Record.AddDeclRef(D->Ctor);
678  VisitFunctionDecl(D);
679  Record.push_back(D->isCopyDeductionCandidate());
681 }
682 
684  VisitNamedDecl(D);
685  // FIXME: convert to LazyStmtPtr?
686  // Unlike C/C++, method bodies will never be in header files.
687  bool HasBodyStuff = D->getBody() != nullptr;
688  Record.push_back(HasBodyStuff);
689  if (HasBodyStuff) {
690  Record.AddStmt(D->getBody());
691  }
692  Record.AddDeclRef(D->getSelfDecl());
693  Record.AddDeclRef(D->getCmdDecl());
694  Record.push_back(D->isInstanceMethod());
695  Record.push_back(D->isVariadic());
696  Record.push_back(D->isPropertyAccessor());
697  Record.push_back(D->isSynthesizedAccessorStub());
698  Record.push_back(D->isDefined());
699  Record.push_back(D->isOverriding());
700  Record.push_back(D->hasSkippedBody());
701 
702  Record.push_back(D->isRedeclaration());
703  Record.push_back(D->hasRedeclaration());
704  if (D->hasRedeclaration()) {
705  assert(Context.getObjCMethodRedeclaration(D));
706  Record.AddDeclRef(Context.getObjCMethodRedeclaration(D));
707  }
708 
709  // FIXME: stable encoding for @required/@optional
710  Record.push_back(D->getImplementationControl());
711  // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway/nullability
712  Record.push_back(D->getObjCDeclQualifier());
713  Record.push_back(D->hasRelatedResultType());
714  Record.AddTypeRef(D->getReturnType());
715  Record.AddTypeSourceInfo(D->getReturnTypeSourceInfo());
716  Record.AddSourceLocation(D->getEndLoc());
717  Record.push_back(D->param_size());
718  for (const auto *P : D->parameters())
719  Record.AddDeclRef(P);
720 
721  Record.push_back(D->getSelLocsKind());
722  unsigned NumStoredSelLocs = D->getNumStoredSelLocs();
723  SourceLocation *SelLocs = D->getStoredSelLocs();
724  Record.push_back(NumStoredSelLocs);
725  for (unsigned i = 0; i != NumStoredSelLocs; ++i)
726  Record.AddSourceLocation(SelLocs[i]);
727 
729 }
730 
732  VisitTypedefNameDecl(D);
733  Record.push_back(D->Variance);
734  Record.push_back(D->Index);
735  Record.AddSourceLocation(D->VarianceLoc);
736  Record.AddSourceLocation(D->ColonLoc);
737 
739 }
740 
742  VisitNamedDecl(D);
743  Record.AddSourceLocation(D->getAtStartLoc());
744  Record.AddSourceRange(D->getAtEndRange());
745  // Abstract class (no need to define a stable serialization::DECL code).
746 }
747 
749  VisitRedeclarable(D);
750  VisitObjCContainerDecl(D);
751  Record.AddTypeRef(QualType(D->getTypeForDecl(), 0));
752  AddObjCTypeParamList(D->TypeParamList);
753 
754  Record.push_back(D->isThisDeclarationADefinition());
755  if (D->isThisDeclarationADefinition()) {
756  // Write the DefinitionData
757  ObjCInterfaceDecl::DefinitionData &Data = D->data();
758 
759  Record.AddTypeSourceInfo(D->getSuperClassTInfo());
760  Record.AddSourceLocation(D->getEndOfDefinitionLoc());
761  Record.push_back(Data.HasDesignatedInitializers);
762 
763  // Write out the protocols that are directly referenced by the @interface.
764  Record.push_back(Data.ReferencedProtocols.size());
765  for (const auto *P : D->protocols())
766  Record.AddDeclRef(P);
767  for (const auto &PL : D->protocol_locs())
768  Record.AddSourceLocation(PL);
769 
770  // Write out the protocols that are transitively referenced.
771  Record.push_back(Data.AllReferencedProtocols.size());
773  P = Data.AllReferencedProtocols.begin(),
774  PEnd = Data.AllReferencedProtocols.end();
775  P != PEnd; ++P)
776  Record.AddDeclRef(*P);
777 
778 
779  if (ObjCCategoryDecl *Cat = D->getCategoryListRaw()) {
780  // Ensure that we write out the set of categories for this class.
781  Writer.ObjCClassesWithCategories.insert(D);
782 
783  // Make sure that the categories get serialized.
784  for (; Cat; Cat = Cat->getNextClassCategoryRaw())
785  (void)Writer.GetDeclRef(Cat);
786  }
787  }
788 
790 }
791 
793  VisitFieldDecl(D);
794  // FIXME: stable encoding for @public/@private/@protected/@package
795  Record.push_back(D->getAccessControl());
796  Record.push_back(D->getSynthesize());
797 
798  if (D->getDeclContext() == D->getLexicalDeclContext() &&
799  !D->hasAttrs() &&
800  !D->isImplicit() &&
801  !D->isUsed(false) &&
802  !D->isInvalidDecl() &&
803  !D->isReferenced() &&
804  !D->isModulePrivate() &&
805  !D->getBitWidth() &&
806  !D->hasExtInfo() &&
807  D->getDeclName())
808  AbbrevToUse = Writer.getDeclObjCIvarAbbrev();
809 
811 }
812 
814  VisitRedeclarable(D);
815  VisitObjCContainerDecl(D);
816 
817  Record.push_back(D->isThisDeclarationADefinition());
818  if (D->isThisDeclarationADefinition()) {
819  Record.push_back(D->protocol_size());
820  for (const auto *I : D->protocols())
821  Record.AddDeclRef(I);
822  for (const auto &PL : D->protocol_locs())
823  Record.AddSourceLocation(PL);
824  }
825 
827 }
828 
830  VisitFieldDecl(D);
832 }
833 
835  VisitObjCContainerDecl(D);
836  Record.AddSourceLocation(D->getCategoryNameLoc());
837  Record.AddSourceLocation(D->getIvarLBraceLoc());
838  Record.AddSourceLocation(D->getIvarRBraceLoc());
839  Record.AddDeclRef(D->getClassInterface());
840  AddObjCTypeParamList(D->TypeParamList);
841  Record.push_back(D->protocol_size());
842  for (const auto *I : D->protocols())
843  Record.AddDeclRef(I);
844  for (const auto &PL : D->protocol_locs())
845  Record.AddSourceLocation(PL);
847 }
848 
850  VisitNamedDecl(D);
851  Record.AddDeclRef(D->getClassInterface());
853 }
854 
856  VisitNamedDecl(D);
857  Record.AddSourceLocation(D->getAtLoc());
858  Record.AddSourceLocation(D->getLParenLoc());
859  Record.AddTypeRef(D->getType());
860  Record.AddTypeSourceInfo(D->getTypeSourceInfo());
861  // FIXME: stable encoding
862  Record.push_back((unsigned)D->getPropertyAttributes());
863  Record.push_back((unsigned)D->getPropertyAttributesAsWritten());
864  // FIXME: stable encoding
865  Record.push_back((unsigned)D->getPropertyImplementation());
866  Record.AddDeclarationName(D->getGetterName());
867  Record.AddSourceLocation(D->getGetterNameLoc());
868  Record.AddDeclarationName(D->getSetterName());
869  Record.AddSourceLocation(D->getSetterNameLoc());
870  Record.AddDeclRef(D->getGetterMethodDecl());
871  Record.AddDeclRef(D->getSetterMethodDecl());
872  Record.AddDeclRef(D->getPropertyIvarDecl());
874 }
875 
877  VisitObjCContainerDecl(D);
878  Record.AddDeclRef(D->getClassInterface());
879  // Abstract class (no need to define a stable serialization::DECL code).
880 }
881 
883  VisitObjCImplDecl(D);
884  Record.AddSourceLocation(D->getCategoryNameLoc());
886 }
887 
889  VisitObjCImplDecl(D);
890  Record.AddDeclRef(D->getSuperClass());
891  Record.AddSourceLocation(D->getSuperClassLoc());
892  Record.AddSourceLocation(D->getIvarLBraceLoc());
893  Record.AddSourceLocation(D->getIvarRBraceLoc());
894  Record.push_back(D->hasNonZeroConstructors());
895  Record.push_back(D->hasDestructors());
896  Record.push_back(D->NumIvarInitializers);
897  if (D->NumIvarInitializers)
898  Record.AddCXXCtorInitializers(
899  llvm::makeArrayRef(D->init_begin(), D->init_end()));
901 }
902 
904  VisitDecl(D);
905  Record.AddSourceLocation(D->getBeginLoc());
906  Record.AddDeclRef(D->getPropertyDecl());
907  Record.AddDeclRef(D->getPropertyIvarDecl());
908  Record.AddSourceLocation(D->getPropertyIvarDeclLoc());
909  Record.AddDeclRef(D->getGetterMethodDecl());
910  Record.AddDeclRef(D->getSetterMethodDecl());
911  Record.AddStmt(D->getGetterCXXConstructor());
912  Record.AddStmt(D->getSetterCXXAssignment());
914 }
915 
917  VisitDeclaratorDecl(D);
918  Record.push_back(D->isMutable());
919 
920  FieldDecl::InitStorageKind ISK = D->InitStorage.getInt();
921  Record.push_back(ISK);
922  if (ISK == FieldDecl::ISK_CapturedVLAType)
923  Record.AddTypeRef(QualType(D->getCapturedVLAType(), 0));
924  else if (ISK)
925  Record.AddStmt(D->getInClassInitializer());
926 
927  Record.AddStmt(D->getBitWidth());
928 
929  if (!D->getDeclName())
930  Record.AddDeclRef(Context.getInstantiatedFromUnnamedFieldDecl(D));
931 
932  if (D->getDeclContext() == D->getLexicalDeclContext() &&
933  !D->hasAttrs() &&
934  !D->isImplicit() &&
935  !D->isUsed(false) &&
936  !D->isInvalidDecl() &&
937  !D->isReferenced() &&
939  !D->isModulePrivate() &&
940  !D->getBitWidth() &&
941  !D->hasInClassInitializer() &&
942  !D->hasCapturedVLAType() &&
943  !D->hasExtInfo() &&
946  D->getDeclName())
947  AbbrevToUse = Writer.getDeclFieldAbbrev();
948 
950 }
951 
953  VisitDeclaratorDecl(D);
954  Record.AddIdentifierRef(D->getGetterId());
955  Record.AddIdentifierRef(D->getSetterId());
957 }
958 
960  VisitValueDecl(D);
961  MSGuidDecl::Parts Parts = D->getParts();
962  Record.push_back(Parts.Part1);
963  Record.push_back(Parts.Part2);
964  Record.push_back(Parts.Part3);
965  for (auto C : Parts.Part4And5)
966  Record.push_back(C);
968 }
969 
971  VisitValueDecl(D);
972  Record.AddAPValue(D->getValue());
974 }
975 
977  VisitValueDecl(D);
978  Record.push_back(D->getChainingSize());
979 
980  for (const auto *P : D->chain())
981  Record.AddDeclRef(P);
983 }
984 
986  VisitRedeclarable(D);
987  VisitDeclaratorDecl(D);
988  Record.push_back(D->getStorageClass());
989  Record.push_back(D->getTSCSpec());
990  Record.push_back(D->getInitStyle());
991  Record.push_back(D->isARCPseudoStrong());
992  if (!isa<ParmVarDecl>(D)) {
993  Record.push_back(D->isThisDeclarationADemotedDefinition());
994  Record.push_back(D->isExceptionVariable());
995  Record.push_back(D->isNRVOVariable());
996  Record.push_back(D->isCXXForRangeDecl());
997  Record.push_back(D->isObjCForDecl());
998  Record.push_back(D->isInline());
999  Record.push_back(D->isInlineSpecified());
1000  Record.push_back(D->isConstexpr());
1001  Record.push_back(D->isInitCapture());
1002  Record.push_back(D->isPreviousDeclInSameBlockScope());
1003  if (const auto *IPD = dyn_cast<ImplicitParamDecl>(D))
1004  Record.push_back(static_cast<unsigned>(IPD->getParameterKind()));
1005  else
1006  Record.push_back(0);
1007  Record.push_back(D->isEscapingByref());
1008  }
1009  Record.push_back(D->getLinkageInternal());
1010 
1011  Record.AddVarDeclInit(D);
1012 
1013  if (D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) {
1014  BlockVarCopyInit Init = Writer.Context->getBlockVarCopyInit(D);
1015  Record.AddStmt(Init.getCopyExpr());
1016  if (Init.getCopyExpr())
1017  Record.push_back(Init.canThrow());
1018  }
1019 
1020  if (D->getStorageDuration() == SD_Static) {
1021  bool ModulesCodegen = false;
1022  if (Writer.WritingModule &&
1024  !isa<VarTemplateSpecializationDecl>(D)) {
1025  // When building a C++ Modules TS module interface unit, a strong
1026  // definition in the module interface is provided by the compilation of
1027  // that module interface unit, not by its users. (Inline variables are
1028  // still emitted in module users.)
1029  ModulesCodegen =
1030  (Writer.WritingModule->Kind == Module::ModuleInterfaceUnit ||
1031  (D->hasAttr<DLLExportAttr>() &&
1032  Writer.Context->getLangOpts().BuildingPCHWithObjectFile)) &&
1033  Writer.Context->GetGVALinkageForVariable(D) == GVA_StrongExternal;
1034  }
1035  Record.push_back(ModulesCodegen);
1036  if (ModulesCodegen)
1037  Writer.ModularCodegenDecls.push_back(Writer.GetDeclRef(D));
1038  }
1039 
1040  enum {
1041  VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
1042  };
1043  if (VarTemplateDecl *TemplD = D->getDescribedVarTemplate()) {
1044  Record.push_back(VarTemplate);
1045  Record.AddDeclRef(TemplD);
1046  } else if (MemberSpecializationInfo *SpecInfo
1047  = D->getMemberSpecializationInfo()) {
1048  Record.push_back(StaticDataMemberSpecialization);
1049  Record.AddDeclRef(SpecInfo->getInstantiatedFrom());
1050  Record.push_back(SpecInfo->getTemplateSpecializationKind());
1051  Record.AddSourceLocation(SpecInfo->getPointOfInstantiation());
1052  } else {
1053  Record.push_back(VarNotTemplate);
1054  }
1055 
1056  if (D->getDeclContext() == D->getLexicalDeclContext() &&
1057  !D->hasAttrs() &&
1058  !D->isImplicit() &&
1059  !D->isUsed(false) &&
1060  !D->isInvalidDecl() &&
1061  !D->isReferenced() &&
1063  D->getAccess() == AS_none &&
1064  !D->isModulePrivate() &&
1067  !D->hasExtInfo() &&
1068  D->getFirstDecl() == D->getMostRecentDecl() &&
1069  D->getKind() == Decl::Var &&
1070  !D->isInline() &&
1071  !D->isConstexpr() &&
1072  !D->isInitCapture() &&
1074  !(D->hasAttr<BlocksAttr>() && D->getType()->getAsCXXRecordDecl()) &&
1075  !D->isEscapingByref() &&
1076  D->getStorageDuration() != SD_Static &&
1078  AbbrevToUse = Writer.getDeclVarAbbrev();
1079 
1080  Code = serialization::DECL_VAR;
1081 }
1082 
1084  VisitVarDecl(D);
1086 }
1087 
1089  VisitVarDecl(D);
1090  Record.push_back(D->isObjCMethodParameter());
1091  Record.push_back(D->getFunctionScopeDepth());
1092  Record.push_back(D->getFunctionScopeIndex());
1093  Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding
1094  Record.push_back(D->isKNRPromoted());
1095  Record.push_back(D->hasInheritedDefaultArg());
1096  Record.push_back(D->hasUninstantiatedDefaultArg());
1097  if (D->hasUninstantiatedDefaultArg())
1098  Record.AddStmt(D->getUninstantiatedDefaultArg());
1100 
1101  // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here
1102  // we dynamically check for the properties that we optimize for, but don't
1103  // know are true of all PARM_VAR_DECLs.
1104  if (D->getDeclContext() == D->getLexicalDeclContext() &&
1105  !D->hasAttrs() &&
1106  !D->hasExtInfo() &&
1107  !D->isImplicit() &&
1108  !D->isUsed(false) &&
1109  !D->isInvalidDecl() &&
1110  !D->isReferenced() &&
1111  D->getAccess() == AS_none &&
1112  !D->isModulePrivate() &&
1113  D->getStorageClass() == 0 &&
1114  D->getInitStyle() == VarDecl::CInit && // Can params have anything else?
1115  D->getFunctionScopeDepth() == 0 &&
1116  D->getObjCDeclQualifier() == 0 &&
1117  !D->isKNRPromoted() &&
1118  !D->hasInheritedDefaultArg() &&
1119  D->getInit() == nullptr &&
1120  !D->hasUninstantiatedDefaultArg()) // No default expr.
1121  AbbrevToUse = Writer.getDeclParmVarAbbrev();
1122 
1123  // Check things we know are true of *every* PARM_VAR_DECL, which is more than
1124  // just us assuming it.
1125  assert(!D->getTSCSpec() && "PARM_VAR_DECL can't use TLS");
1127  && "PARM_VAR_DECL can't be demoted definition.");
1128  assert(D->getAccess() == AS_none && "PARM_VAR_DECL can't be public/private");
1129  assert(!D->isExceptionVariable() && "PARM_VAR_DECL can't be exception var");
1130  assert(D->getPreviousDecl() == nullptr && "PARM_VAR_DECL can't be redecl");
1131  assert(!D->isStaticDataMember() &&
1132  "PARM_VAR_DECL can't be static data member");
1133 }
1134 
1136  // Record the number of bindings first to simplify deserialization.
1137  Record.push_back(D->bindings().size());
1138 
1139  VisitVarDecl(D);
1140  for (auto *B : D->bindings())
1141  Record.AddDeclRef(B);
1143 }
1144 
1146  VisitValueDecl(D);
1147  Record.AddStmt(D->getBinding());
1149 }
1150 
1152  VisitDecl(D);
1153  Record.AddStmt(D->getAsmString());
1154  Record.AddSourceLocation(D->getRParenLoc());
1156 }
1157 
1159  VisitDecl(D);
1161 }
1162 
1165  VisitDecl(D);
1166  Record.AddDeclRef(D->getExtendingDecl());
1167  Record.AddStmt(D->getTemporaryExpr());
1168  Record.push_back(static_cast<bool>(D->getValue()));
1169  if (D->getValue())
1170  Record.AddAPValue(*D->getValue());
1171  Record.push_back(D->getManglingNumber());
1173 }
1175  VisitDecl(D);
1176  Record.AddStmt(D->getBody());
1177  Record.AddTypeSourceInfo(D->getSignatureAsWritten());
1178  Record.push_back(D->param_size());
1179  for (ParmVarDecl *P : D->parameters())
1180  Record.AddDeclRef(P);
1181  Record.push_back(D->isVariadic());
1182  Record.push_back(D->blockMissingReturnType());
1183  Record.push_back(D->isConversionFromLambda());
1184  Record.push_back(D->doesNotEscape());
1185  Record.push_back(D->canAvoidCopyToHeap());
1186  Record.push_back(D->capturesCXXThis());
1187  Record.push_back(D->getNumCaptures());
1188  for (const auto &capture : D->captures()) {
1189  Record.AddDeclRef(capture.getVariable());
1190 
1191  unsigned flags = 0;
1192  if (capture.isByRef()) flags |= 1;
1193  if (capture.isNested()) flags |= 2;
1194  if (capture.hasCopyExpr()) flags |= 4;
1195  Record.push_back(flags);
1196 
1197  if (capture.hasCopyExpr()) Record.AddStmt(capture.getCopyExpr());
1198  }
1199 
1201 }
1202 
1204  Record.push_back(CD->getNumParams());
1205  VisitDecl(CD);
1206  Record.push_back(CD->getContextParamPosition());
1207  Record.push_back(CD->isNothrow() ? 1 : 0);
1208  // Body is stored by VisitCapturedStmt.
1209  for (unsigned I = 0; I < CD->getNumParams(); ++I)
1210  Record.AddDeclRef(CD->getParam(I));
1212 }
1213 
1215  VisitDecl(D);
1216  Record.push_back(D->getLanguage());
1217  Record.AddSourceLocation(D->getExternLoc());
1218  Record.AddSourceLocation(D->getRBraceLoc());
1220 }
1221 
1223  VisitDecl(D);
1224  Record.AddSourceLocation(D->getRBraceLoc());
1226 }
1227 
1229  VisitNamedDecl(D);
1230  Record.AddSourceLocation(D->getBeginLoc());
1232 }
1233 
1234 
1236  VisitRedeclarable(D);
1237  VisitNamedDecl(D);
1238  Record.push_back(D->isInline());
1239  Record.AddSourceLocation(D->getBeginLoc());
1240  Record.AddSourceLocation(D->getRBraceLoc());
1241 
1242  if (D->isOriginalNamespace())
1243  Record.AddDeclRef(D->getAnonymousNamespace());
1245 
1246  if (Writer.hasChain() && D->isAnonymousNamespace() &&
1247  D == D->getMostRecentDecl()) {
1248  // This is a most recent reopening of the anonymous namespace. If its parent
1249  // is in a previous PCH (or is the TU), mark that parent for update, because
1250  // the original namespace always points to the latest re-opening of its
1251  // anonymous namespace.
1252  Decl *Parent = cast<Decl>(
1254  if (Parent->isFromASTFile() || isa<TranslationUnitDecl>(Parent)) {
1255  Writer.DeclUpdates[Parent].push_back(
1256  ASTWriter::DeclUpdate(UPD_CXX_ADDED_ANONYMOUS_NAMESPACE, D));
1257  }
1258  }
1259 }
1260 
1262  VisitRedeclarable(D);
1263  VisitNamedDecl(D);
1264  Record.AddSourceLocation(D->getNamespaceLoc());
1265  Record.AddSourceLocation(D->getTargetNameLoc());
1266  Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1267  Record.AddDeclRef(D->getNamespace());
1269 }
1270 
1272  VisitNamedDecl(D);
1273  Record.AddSourceLocation(D->getUsingLoc());
1274  Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1275  Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1276  Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1277  Record.push_back(D->hasTypename());
1278  Record.AddDeclRef(Context.getInstantiatedFromUsingDecl(D));
1280 }
1281 
1283  VisitNamedDecl(D);
1284  Record.AddSourceLocation(D->getUsingLoc());
1285  Record.AddSourceLocation(D->getEnumLoc());
1286  Record.AddDeclRef(D->getEnumDecl());
1287  Record.AddDeclRef(D->FirstUsingShadow.getPointer());
1288  Record.AddDeclRef(Context.getInstantiatedFromUsingEnumDecl(D));
1290 }
1291 
1293  Record.push_back(D->NumExpansions);
1294  VisitNamedDecl(D);
1295  Record.AddDeclRef(D->getInstantiatedFromUsingDecl());
1296  for (auto *E : D->expansions())
1297  Record.AddDeclRef(E);
1299 }
1300 
1302  VisitRedeclarable(D);
1303  VisitNamedDecl(D);
1304  Record.AddDeclRef(D->getTargetDecl());
1305  Record.push_back(D->getIdentifierNamespace());
1306  Record.AddDeclRef(D->UsingOrNextShadow);
1307  Record.AddDeclRef(Context.getInstantiatedFromUsingShadowDecl(D));
1309 }
1310 
1313  VisitUsingShadowDecl(D);
1314  Record.AddDeclRef(D->NominatedBaseClassShadowDecl);
1315  Record.AddDeclRef(D->ConstructedBaseClassShadowDecl);
1316  Record.push_back(D->IsVirtual);
1318 }
1319 
1321  VisitNamedDecl(D);
1322  Record.AddSourceLocation(D->getUsingLoc());
1323  Record.AddSourceLocation(D->getNamespaceKeyLocation());
1324  Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1325  Record.AddDeclRef(D->getNominatedNamespace());
1326  Record.AddDeclRef(dyn_cast<Decl>(D->getCommonAncestor()));
1328 }
1329 
1331  VisitValueDecl(D);
1332  Record.AddSourceLocation(D->getUsingLoc());
1333  Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1334  Record.AddDeclarationNameLoc(D->DNLoc, D->getDeclName());
1335  Record.AddSourceLocation(D->getEllipsisLoc());
1337 }
1338 
1341  VisitTypeDecl(D);
1342  Record.AddSourceLocation(D->getTypenameLoc());
1343  Record.AddNestedNameSpecifierLoc(D->getQualifierLoc());
1344  Record.AddSourceLocation(D->getEllipsisLoc());
1346 }
1347 
1350  VisitNamedDecl(D);
1352 }
1353 
1355  VisitRecordDecl(D);
1356 
1357  enum {
1358  CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
1359  };
1360  if (ClassTemplateDecl *TemplD = D->getDescribedClassTemplate()) {
1361  Record.push_back(CXXRecTemplate);
1362  Record.AddDeclRef(TemplD);
1363  } else if (MemberSpecializationInfo *MSInfo
1364  = D->getMemberSpecializationInfo()) {
1365  Record.push_back(CXXRecMemberSpecialization);
1366  Record.AddDeclRef(MSInfo->getInstantiatedFrom());
1367  Record.push_back(MSInfo->getTemplateSpecializationKind());
1368  Record.AddSourceLocation(MSInfo->getPointOfInstantiation());
1369  } else {
1370  Record.push_back(CXXRecNotTemplate);
1371  }
1372 
1373  Record.push_back(D->isThisDeclarationADefinition());
1375  Record.AddCXXDefinitionData(D);
1376 
1377  // Store (what we currently believe to be) the key function to avoid
1378  // deserializing every method so we can compute it.
1379  if (D->isCompleteDefinition())
1380  Record.AddDeclRef(Context.getCurrentKeyFunction(D));
1381 
1383 }
1384 
1386  VisitFunctionDecl(D);
1387  if (D->isCanonicalDecl()) {
1388  Record.push_back(D->size_overridden_methods());
1389  for (const CXXMethodDecl *MD : D->overridden_methods())
1390  Record.AddDeclRef(MD);
1391  } else {
1392  // We only need to record overridden methods once for the canonical decl.
1393  Record.push_back(0);
1394  }
1395 
1396  if (D->getDeclContext() == D->getLexicalDeclContext() &&
1397  D->getFirstDecl() == D->getMostRecentDecl() &&
1398  !D->isInvalidDecl() &&
1399  !D->hasAttrs() &&
1402  !D->hasExtInfo() &&
1403  !D->hasInheritedPrototype() &&
1404  D->hasWrittenPrototype())
1405  AbbrevToUse = Writer.getDeclCXXMethodAbbrev();
1406 
1408 }
1409 
1411  Record.push_back(D->getTrailingAllocKind());
1413  if (auto Inherited = D->getInheritedConstructor()) {
1414  Record.AddDeclRef(Inherited.getShadowDecl());
1415  Record.AddDeclRef(Inherited.getConstructor());
1416  }
1417 
1418  VisitCXXMethodDecl(D);
1420 }
1421 
1423  VisitCXXMethodDecl(D);
1424 
1425  Record.AddDeclRef(D->getOperatorDelete());
1426  if (D->getOperatorDelete())
1427  Record.AddStmt(D->getOperatorDeleteThisArg());
1428 
1430 }
1431 
1434  VisitCXXMethodDecl(D);
1436 }
1437 
1439  VisitDecl(D);
1440  Record.push_back(Writer.getSubmoduleID(D->getImportedModule()));
1441  ArrayRef<SourceLocation> IdentifierLocs = D->getIdentifierLocs();
1442  Record.push_back(!IdentifierLocs.empty());
1443  if (IdentifierLocs.empty()) {
1444  Record.AddSourceLocation(D->getEndLoc());
1445  Record.push_back(1);
1446  } else {
1447  for (unsigned I = 0, N = IdentifierLocs.size(); I != N; ++I)
1448  Record.AddSourceLocation(IdentifierLocs[I]);
1449  Record.push_back(IdentifierLocs.size());
1450  }
1451  // Note: the number of source locations must always be the last element in
1452  // the record.
1454 }
1455 
1457  VisitDecl(D);
1458  Record.AddSourceLocation(D->getColonLoc());
1460 }
1461 
1463  // Record the number of friend type template parameter lists here
1464  // so as to simplify memory allocation during deserialization.
1465  Record.push_back(D->NumTPLists);
1466  VisitDecl(D);
1467  bool hasFriendDecl = D->Friend.is<NamedDecl*>();
1468  Record.push_back(hasFriendDecl);
1469  if (hasFriendDecl)
1470  Record.AddDeclRef(D->getFriendDecl());
1471  else
1472  Record.AddTypeSourceInfo(D->getFriendType());
1473  for (unsigned i = 0; i < D->NumTPLists; ++i)
1474  Record.AddTemplateParameterList(D->getFriendTypeTemplateParameterList(i));
1475  Record.AddDeclRef(D->getNextFriend());
1476  Record.push_back(D->UnsupportedFriend);
1477  Record.AddSourceLocation(D->FriendLoc);
1479 }
1480 
1482  VisitDecl(D);
1483  Record.push_back(D->getNumTemplateParameters());
1484  for (unsigned i = 0, e = D->getNumTemplateParameters(); i != e; ++i)
1485  Record.AddTemplateParameterList(D->getTemplateParameterList(i));
1486  Record.push_back(D->getFriendDecl() != nullptr);
1487  if (D->getFriendDecl())
1488  Record.AddDeclRef(D->getFriendDecl());
1489  else
1490  Record.AddTypeSourceInfo(D->getFriendType());
1491  Record.AddSourceLocation(D->getFriendLoc());
1493 }
1494 
1496  VisitNamedDecl(D);
1497 
1498  Record.AddDeclRef(D->getTemplatedDecl());
1499  Record.AddTemplateParameterList(D->getTemplateParameters());
1500 }
1501 
1503  VisitTemplateDecl(D);
1504  Record.AddStmt(D->getConstraintExpr());
1506 }
1507 
1510 }
1511 
1513  VisitRedeclarable(D);
1514 
1515  // Emit data to initialize CommonOrPrev before VisitTemplateDecl so that
1516  // getCommonPtr() can be used while this is still initializing.
1517  if (D->isFirstDecl()) {
1518  // This declaration owns the 'common' pointer, so serialize that data now.
1519  Record.AddDeclRef(D->getInstantiatedFromMemberTemplate());
1521  Record.push_back(D->isMemberSpecialization());
1522  }
1523 
1524  VisitTemplateDecl(D);
1525  Record.push_back(D->getIdentifierNamespace());
1526 }
1527 
1529  VisitRedeclarableTemplateDecl(D);
1530 
1531  if (D->isFirstDecl())
1532  AddTemplateSpecializations(D);
1534 }
1535 
1538  RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1539 
1540  VisitCXXRecordDecl(D);
1541 
1542  llvm::PointerUnion<ClassTemplateDecl *,
1545  if (Decl *InstFromD = InstFrom.dyn_cast<ClassTemplateDecl *>()) {
1546  Record.AddDeclRef(InstFromD);
1547  } else {
1548  Record.AddDeclRef(InstFrom.get<ClassTemplatePartialSpecializationDecl *>());
1549  Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1550  }
1551 
1552  Record.AddTemplateArgumentList(&D->getTemplateArgs());
1553  Record.AddSourceLocation(D->getPointOfInstantiation());
1554  Record.push_back(D->getSpecializationKind());
1555  Record.push_back(D->isCanonicalDecl());
1556 
1557  if (D->isCanonicalDecl()) {
1558  // When reading, we'll add it to the folding set of the following template.
1559  Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1560  }
1561 
1562  // Explicit info.
1563  Record.AddTypeSourceInfo(D->getTypeAsWritten());
1564  if (D->getTypeAsWritten()) {
1565  Record.AddSourceLocation(D->getExternLoc());
1566  Record.AddSourceLocation(D->getTemplateKeywordLoc());
1567  }
1568 
1570 }
1571 
1574  Record.AddTemplateParameterList(D->getTemplateParameters());
1575  Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1576 
1577  VisitClassTemplateSpecializationDecl(D);
1578 
1579  // These are read/set from/to the first declaration.
1580  if (D->getPreviousDecl() == nullptr) {
1581  Record.AddDeclRef(D->getInstantiatedFromMember());
1582  Record.push_back(D->isMemberSpecialization());
1583  }
1584 
1586 }
1587 
1589  VisitRedeclarableTemplateDecl(D);
1590 
1591  if (D->isFirstDecl())
1592  AddTemplateSpecializations(D);
1594 }
1595 
1598  RegisterTemplateSpecialization(D->getSpecializedTemplate(), D);
1599 
1600  VisitVarDecl(D);
1601 
1602  llvm::PointerUnion<VarTemplateDecl *, VarTemplatePartialSpecializationDecl *>
1603  InstFrom = D->getSpecializedTemplateOrPartial();
1604  if (Decl *InstFromD = InstFrom.dyn_cast<VarTemplateDecl *>()) {
1605  Record.AddDeclRef(InstFromD);
1606  } else {
1607  Record.AddDeclRef(InstFrom.get<VarTemplatePartialSpecializationDecl *>());
1608  Record.AddTemplateArgumentList(&D->getTemplateInstantiationArgs());
1609  }
1610 
1611  // Explicit info.
1612  Record.AddTypeSourceInfo(D->getTypeAsWritten());
1613  if (D->getTypeAsWritten()) {
1614  Record.AddSourceLocation(D->getExternLoc());
1615  Record.AddSourceLocation(D->getTemplateKeywordLoc());
1616  }
1617 
1618  Record.AddTemplateArgumentList(&D->getTemplateArgs());
1619  Record.AddSourceLocation(D->getPointOfInstantiation());
1620  Record.push_back(D->getSpecializationKind());
1621  Record.push_back(D->IsCompleteDefinition);
1622  Record.push_back(D->isCanonicalDecl());
1623 
1624  if (D->isCanonicalDecl()) {
1625  // When reading, we'll add it to the folding set of the following template.
1626  Record.AddDeclRef(D->getSpecializedTemplate()->getCanonicalDecl());
1627  }
1628 
1630 }
1631 
1634  Record.AddTemplateParameterList(D->getTemplateParameters());
1635  Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1636 
1637  VisitVarTemplateSpecializationDecl(D);
1638 
1639  // These are read/set from/to the first declaration.
1640  if (D->getPreviousDecl() == nullptr) {
1641  Record.AddDeclRef(D->getInstantiatedFromMember());
1642  Record.push_back(D->isMemberSpecialization());
1643  }
1644 
1646 }
1647 
1650  VisitDecl(D);
1651  Record.AddDeclRef(D->getSpecialization());
1652  Record.push_back(D->hasExplicitTemplateArgs());
1653  if (D->hasExplicitTemplateArgs())
1654  Record.AddASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
1656 }
1657 
1658 
1660  VisitRedeclarableTemplateDecl(D);
1661 
1662  if (D->isFirstDecl())
1663  AddTemplateSpecializations(D);
1665 }
1666 
1668  Record.push_back(D->hasTypeConstraint());
1669  VisitTypeDecl(D);
1670 
1671  Record.push_back(D->wasDeclaredWithTypename());
1672 
1673  const TypeConstraint *TC = D->getTypeConstraint();
1674  Record.push_back(TC != nullptr);
1675  if (TC) {
1676  Record.AddNestedNameSpecifierLoc(TC->getNestedNameSpecifierLoc());
1677  Record.AddDeclarationNameInfo(TC->getConceptNameInfo());
1678  Record.AddDeclRef(TC->getNamedConcept());
1679  Record.push_back(TC->getTemplateArgsAsWritten() != nullptr);
1680  if (TC->getTemplateArgsAsWritten())
1681  Record.AddASTTemplateArgumentListInfo(TC->getTemplateArgsAsWritten());
1682  Record.AddStmt(TC->getImmediatelyDeclaredConstraint());
1683  Record.push_back(D->isExpandedParameterPack());
1684  if (D->isExpandedParameterPack())
1685  Record.push_back(D->getNumExpansionParameters());
1686  }
1687 
1688  bool OwnsDefaultArg = D->hasDefaultArgument() &&
1690  Record.push_back(OwnsDefaultArg);
1691  if (OwnsDefaultArg)
1692  Record.AddTypeSourceInfo(D->getDefaultArgumentInfo());
1693 
1695 }
1696 
1698  // For an expanded parameter pack, record the number of expansion types here
1699  // so that it's easier for deserialization to allocate the right amount of
1700  // memory.
1702  Record.push_back(!!TypeConstraint);
1703  if (D->isExpandedParameterPack())
1704  Record.push_back(D->getNumExpansionTypes());
1705 
1706  VisitDeclaratorDecl(D);
1707  // TemplateParmPosition.
1708  Record.push_back(D->getDepth());
1709  Record.push_back(D->getPosition());
1710  if (TypeConstraint)
1711  Record.AddStmt(TypeConstraint);
1712 
1713  if (D->isExpandedParameterPack()) {
1714  for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
1715  Record.AddTypeRef(D->getExpansionType(I));
1716  Record.AddTypeSourceInfo(D->getExpansionTypeSourceInfo(I));
1717  }
1718 
1720  } else {
1721  // Rest of NonTypeTemplateParmDecl.
1722  Record.push_back(D->isParameterPack());
1723  bool OwnsDefaultArg = D->hasDefaultArgument() &&
1725  Record.push_back(OwnsDefaultArg);
1726  if (OwnsDefaultArg)
1727  Record.AddStmt(D->getDefaultArgument());
1729  }
1730 }
1731 
1733  // For an expanded parameter pack, record the number of expansion types here
1734  // so that it's easier for deserialization to allocate the right amount of
1735  // memory.
1736  if (D->isExpandedParameterPack())
1737  Record.push_back(D->getNumExpansionTemplateParameters());
1738 
1739  VisitTemplateDecl(D);
1740  // TemplateParmPosition.
1741  Record.push_back(D->getDepth());
1742  Record.push_back(D->getPosition());
1743 
1744  if (D->isExpandedParameterPack()) {
1745  for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
1746  I != N; ++I)
1747  Record.AddTemplateParameterList(D->getExpansionTemplateParameters(I));
1749  } else {
1750  // Rest of TemplateTemplateParmDecl.
1751  Record.push_back(D->isParameterPack());
1752  bool OwnsDefaultArg = D->hasDefaultArgument() &&
1754  Record.push_back(OwnsDefaultArg);
1755  if (OwnsDefaultArg)
1756  Record.AddTemplateArgumentLoc(D->getDefaultArgument());
1758  }
1759 }
1760 
1762  VisitRedeclarableTemplateDecl(D);
1764 }
1765 
1767  VisitDecl(D);
1768  Record.AddStmt(D->getAssertExpr());
1769  Record.push_back(D->isFailed());
1770  Record.AddStmt(D->getMessage());
1771  Record.AddSourceLocation(D->getRParenLoc());
1773 }
1774 
1775 /// Emit the DeclContext part of a declaration context decl.
1777  Record.AddOffset(Writer.WriteDeclContextLexicalBlock(Context, DC));
1778  Record.AddOffset(Writer.WriteDeclContextVisibleBlock(Context, DC));
1779 }
1780 
1782  assert(IsLocalDecl(D) && "expected a local declaration");
1783 
1784  const Decl *Canon = D->getCanonicalDecl();
1785  if (IsLocalDecl(Canon))
1786  return Canon;
1787 
1788  const Decl *&CacheEntry = FirstLocalDeclCache[Canon];
1789  if (CacheEntry)
1790  return CacheEntry;
1791 
1792  for (const Decl *Redecl = D; Redecl; Redecl = Redecl->getPreviousDecl())
1793  if (IsLocalDecl(Redecl))
1794  D = Redecl;
1795  return CacheEntry = D;
1796 }
1797 
1798 template <typename T>
1800  T *First = D->getFirstDecl();
1801  T *MostRecent = First->getMostRecentDecl();
1802  T *DAsT = static_cast<T *>(D);
1803  if (MostRecent != First) {
1804  assert(isRedeclarableDeclKind(DAsT->getKind()) &&
1805  "Not considered redeclarable?");
1806 
1807  Record.AddDeclRef(First);
1808 
1809  // Write out a list of local redeclarations of this declaration if it's the
1810  // first local declaration in the chain.
1811  const Decl *FirstLocal = Writer.getFirstLocalDecl(DAsT);
1812  if (DAsT == FirstLocal) {
1813  // Emit a list of all imported first declarations so that we can be sure
1814  // that all redeclarations visible to this module are before D in the
1815  // redecl chain.
1816  unsigned I = Record.size();
1817  Record.push_back(0);
1818  if (Writer.Chain)
1819  AddFirstDeclFromEachModule(DAsT, /*IncludeLocal*/false);
1820  // This is the number of imported first declarations + 1.
1821  Record[I] = Record.size() - I;
1822 
1823  // Collect the set of local redeclarations of this declaration, from
1824  // newest to oldest.
1825  ASTWriter::RecordData LocalRedecls;
1826  ASTRecordWriter LocalRedeclWriter(Record, LocalRedecls);
1827  for (const Decl *Prev = FirstLocal->getMostRecentDecl();
1828  Prev != FirstLocal; Prev = Prev->getPreviousDecl())
1829  if (!Prev->isFromASTFile())
1830  LocalRedeclWriter.AddDeclRef(Prev);
1831 
1832  // If we have any redecls, write them now as a separate record preceding
1833  // the declaration itself.
1834  if (LocalRedecls.empty())
1835  Record.push_back(0);
1836  else
1837  Record.AddOffset(LocalRedeclWriter.Emit(LOCAL_REDECLARATIONS));
1838  } else {
1839  Record.push_back(0);
1840  Record.AddDeclRef(FirstLocal);
1841  }
1842 
1843  // Make sure that we serialize both the previous and the most-recent
1844  // declarations, which (transitively) ensures that all declarations in the
1845  // chain get serialized.
1846  //
1847  // FIXME: This is not correct; when we reach an imported declaration we
1848  // won't emit its previous declaration.
1849  (void)Writer.GetDeclRef(D->getPreviousDecl());
1850  (void)Writer.GetDeclRef(MostRecent);
1851  } else {
1852  // We use the sentinel value 0 to indicate an only declaration.
1853  Record.push_back(0);
1854  }
1855 }
1856 
1858  Record.writeOMPChildren(D->Data);
1859  VisitDecl(D);
1861 }
1862 
1864  Record.writeOMPChildren(D->Data);
1865  VisitDecl(D);
1867 }
1868 
1870  Record.writeOMPChildren(D->Data);
1871  VisitDecl(D);
1873 }
1874 
1876  VisitValueDecl(D);
1877  Record.AddSourceLocation(D->getBeginLoc());
1878  Record.AddStmt(D->getCombinerIn());
1879  Record.AddStmt(D->getCombinerOut());
1880  Record.AddStmt(D->getCombiner());
1881  Record.AddStmt(D->getInitOrig());
1882  Record.AddStmt(D->getInitPriv());
1883  Record.AddStmt(D->getInitializer());
1884  Record.push_back(D->getInitializerKind());
1885  Record.AddDeclRef(D->getPrevDeclInScope());
1887 }
1888 
1890  Record.writeOMPChildren(D->Data);
1891  VisitValueDecl(D);
1892  Record.AddDeclarationName(D->getVarName());
1893  Record.AddDeclRef(D->getPrevDeclInScope());
1895 }
1896 
1898  VisitVarDecl(D);
1900 }
1901 
1902 //===----------------------------------------------------------------------===//
1903 // ASTWriter Implementation
1904 //===----------------------------------------------------------------------===//
1905 
1906 void ASTWriter::WriteDeclAbbrevs() {
1907  using namespace llvm;
1908 
1909  std::shared_ptr<BitCodeAbbrev> Abv;
1910 
1911  // Abbreviation for DECL_FIELD
1912  Abv = std::make_shared<BitCodeAbbrev>();
1913  Abv->Add(BitCodeAbbrevOp(serialization::DECL_FIELD));
1914  // Decl
1915  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1916  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1917  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1918  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1919  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1920  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1921  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1922  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1923  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1924  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1925  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1926  // NamedDecl
1927  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1928  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1929  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1930  // ValueDecl
1931  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1932  // DeclaratorDecl
1933  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1934  Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1935  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
1936  // FieldDecl
1937  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1938  Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
1939  // Type Source Info
1940  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1941  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1942  DeclFieldAbbrev = Stream.EmitAbbrev(std::move(Abv));
1943 
1944  // Abbreviation for DECL_OBJC_IVAR
1945  Abv = std::make_shared<BitCodeAbbrev>();
1946  Abv->Add(BitCodeAbbrevOp(serialization::DECL_OBJC_IVAR));
1947  // Decl
1948  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1949  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1950  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1951  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1952  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1953  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1954  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1955  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1956  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // AccessSpecifier
1957  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1958  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1959  // NamedDecl
1960  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1961  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
1962  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
1963  // ValueDecl
1964  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
1965  // DeclaratorDecl
1966  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
1967  Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
1968  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
1969  // FieldDecl
1970  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isMutable
1971  Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
1972  // ObjC Ivar
1973  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getAccessControl
1974  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getSynthesize
1975  // Type Source Info
1976  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
1977  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
1978  DeclObjCIvarAbbrev = Stream.EmitAbbrev(std::move(Abv));
1979 
1980  // Abbreviation for DECL_ENUM
1981  Abv = std::make_shared<BitCodeAbbrev>();
1982  Abv->Add(BitCodeAbbrevOp(serialization::DECL_ENUM));
1983  // Redeclarable
1984  Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
1985  // Decl
1986  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
1987  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
1988  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
1989  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
1990  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
1991  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
1992  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
1993  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
1994  Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
1995  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
1996  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
1997  // NamedDecl
1998  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
1999  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2000  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2001  // TypeDecl
2002  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2003  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2004  // TagDecl
2005  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2006  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
2007  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
2008  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
2009  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
2010  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
2011  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2012  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2013  Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
2014  // EnumDecl
2015  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // AddTypeRef
2016  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IntegerType
2017  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getPromotionType
2018  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumPositiveBits
2019  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getNumNegativeBits
2020  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScoped
2021  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isScopedUsingClassTag
2022  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isFixed
2023  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));// ODRHash
2024  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InstantiatedMembEnum
2025  // DC
2026  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2027  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2028  DeclEnumAbbrev = Stream.EmitAbbrev(std::move(Abv));
2029 
2030  // Abbreviation for DECL_RECORD
2031  Abv = std::make_shared<BitCodeAbbrev>();
2032  Abv->Add(BitCodeAbbrevOp(serialization::DECL_RECORD));
2033  // Redeclarable
2034  Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
2035  // Decl
2036  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2037  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2038  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
2039  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2040  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2041  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2042  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
2043  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
2044  Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
2045  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
2046  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2047  // NamedDecl
2048  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2049  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2050  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2051  // TypeDecl
2052  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2053  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2054  // TagDecl
2055  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // IdentifierNamespace
2056  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getTagKind
2057  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCompleteDefinition
2058  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // EmbeddedInDeclarator
2059  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsFreeStanding
2060  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsCompleteDefinitionRequired
2061  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2062  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SourceLocation
2063  Abv->Add(BitCodeAbbrevOp(0)); // ExtInfoKind
2064  // RecordDecl
2065  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // FlexibleArrayMember
2066  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // AnonymousStructUnion
2067  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasObjectMember
2068  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // hasVolatileMember
2069 
2070  // isNonTrivialToPrimitiveDefaultInitialize
2071  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2072  // isNonTrivialToPrimitiveCopy
2073  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2074  // isNonTrivialToPrimitiveDestroy
2075  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2076  // hasNonTrivialToPrimitiveDefaultInitializeCUnion
2077  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2078  // hasNonTrivialToPrimitiveDestructCUnion
2079  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2080  // hasNonTrivialToPrimitiveCopyCUnion
2081  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2082  // isParamDestroyedInCallee
2083  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
2084  // getArgPassingRestrictions
2085  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));
2086 
2087  // DC
2088  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LexicalOffset
2089  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // VisibleOffset
2090  DeclRecordAbbrev = Stream.EmitAbbrev(std::move(Abv));
2091 
2092  // Abbreviation for DECL_PARM_VAR
2093  Abv = std::make_shared<BitCodeAbbrev>();
2094  Abv->Add(BitCodeAbbrevOp(serialization::DECL_PARM_VAR));
2095  // Redeclarable
2096  Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
2097  // Decl
2098  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2099  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2100  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
2101  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2102  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2103  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2104  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
2105  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
2106  Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
2107  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
2108  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2109  // NamedDecl
2110  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2111  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2112  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2113  // ValueDecl
2114  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2115  // DeclaratorDecl
2116  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2117  Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
2118  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2119  // VarDecl
2120  Abv->Add(BitCodeAbbrevOp(0)); // SClass
2121  Abv->Add(BitCodeAbbrevOp(0)); // TSCSpec
2122  Abv->Add(BitCodeAbbrevOp(0)); // InitStyle
2123  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
2124  Abv->Add(BitCodeAbbrevOp(0)); // Linkage
2125  Abv->Add(BitCodeAbbrevOp(0)); // HasInit
2126  Abv->Add(BitCodeAbbrevOp(0)); // HasMemberSpecializationInfo
2127  // ParmVarDecl
2128  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsObjCMethodParameter
2129  Abv->Add(BitCodeAbbrevOp(0)); // ScopeDepth
2130  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ScopeIndex
2131  Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier
2132  Abv->Add(BitCodeAbbrevOp(0)); // KNRPromoted
2133  Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedDefaultArg
2134  Abv->Add(BitCodeAbbrevOp(0)); // HasUninstantiatedDefaultArg
2135  // Type Source Info
2136  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2137  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2138  DeclParmVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2139 
2140  // Abbreviation for DECL_TYPEDEF
2141  Abv = std::make_shared<BitCodeAbbrev>();
2142  Abv->Add(BitCodeAbbrevOp(serialization::DECL_TYPEDEF));
2143  // Redeclarable
2144  Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
2145  // Decl
2146  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2147  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2148  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
2149  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2150  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2151  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
2152  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
2153  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
2154  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
2155  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
2156  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2157  // NamedDecl
2158  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2159  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2160  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2161  // TypeDecl
2162  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
2163  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
2164  // TypedefDecl
2165  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2166  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2167  DeclTypedefAbbrev = Stream.EmitAbbrev(std::move(Abv));
2168 
2169  // Abbreviation for DECL_VAR
2170  Abv = std::make_shared<BitCodeAbbrev>();
2171  Abv->Add(BitCodeAbbrevOp(serialization::DECL_VAR));
2172  // Redeclarable
2173  Abv->Add(BitCodeAbbrevOp(0)); // No redeclaration
2174  // Decl
2175  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2176  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2177  Abv->Add(BitCodeAbbrevOp(0)); // isInvalidDecl
2178  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2179  Abv->Add(BitCodeAbbrevOp(0)); // isImplicit
2180  Abv->Add(BitCodeAbbrevOp(0)); // isUsed
2181  Abv->Add(BitCodeAbbrevOp(0)); // isReferenced
2182  Abv->Add(BitCodeAbbrevOp(0)); // TopLevelDeclInObjCContainer
2183  Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier
2184  Abv->Add(BitCodeAbbrevOp(0)); // ModulePrivate
2185  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2186  // NamedDecl
2187  Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier
2188  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
2189  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2190  // ValueDecl
2191  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2192  // DeclaratorDecl
2193  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerStartLoc
2194  Abv->Add(BitCodeAbbrevOp(0)); // hasExtInfo
2195  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2196  // VarDecl
2197  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // SClass
2198  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // TSCSpec
2199  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // InitStyle
2200  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isARCPseudoStrong
2201  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // IsThisDeclarationADemotedDefinition
2202  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isExceptionVariable
2203  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isNRVOVariable
2204  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isCXXForRangeDecl
2205  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isObjCForDecl
2206  Abv->Add(BitCodeAbbrevOp(0)); // isInline
2207  Abv->Add(BitCodeAbbrevOp(0)); // isInlineSpecified
2208  Abv->Add(BitCodeAbbrevOp(0)); // isConstexpr
2209  Abv->Add(BitCodeAbbrevOp(0)); // isInitCapture
2210  Abv->Add(BitCodeAbbrevOp(0)); // isPrevDeclInSameScope
2211  Abv->Add(BitCodeAbbrevOp(0)); // ImplicitParamKind
2212  Abv->Add(BitCodeAbbrevOp(0)); // EscapingByref
2213  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2214  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // HasConstant*
2215  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // VarKind (local enum)
2216  // Type Source Info
2217  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2218  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TypeLoc
2219  DeclVarAbbrev = Stream.EmitAbbrev(std::move(Abv));
2220 
2221  // Abbreviation for DECL_CXX_METHOD
2222  Abv = std::make_shared<BitCodeAbbrev>();
2223  Abv->Add(BitCodeAbbrevOp(serialization::DECL_CXX_METHOD));
2224  // RedeclarableDecl
2225  Abv->Add(BitCodeAbbrevOp(0)); // CanonicalDecl
2226  // Decl
2227  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclContext
2228  Abv->Add(BitCodeAbbrevOp(0)); // LexicalDeclContext
2229  Abv->Add(BitCodeAbbrevOp(0)); // Invalid
2230  Abv->Add(BitCodeAbbrevOp(0)); // HasAttrs
2231  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
2232  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
2233  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
2234  Abv->Add(BitCodeAbbrevOp(0)); // InObjCContainer
2235  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
2236  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
2237  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
2238  // NamedDecl
2239  Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
2240  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Identifier
2241  Abv->Add(BitCodeAbbrevOp(0)); // AnonDeclNumber
2242  // ValueDecl
2243  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2244  // DeclaratorDecl
2245  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // InnerLocStart
2246  Abv->Add(BitCodeAbbrevOp(0)); // HasExtInfo
2247  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // TSIType
2248  // FunctionDecl
2249  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 11)); // IDNS
2250  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // StorageClass
2251  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Inline
2252  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // InlineSpecified
2253  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // VirtualAsWritten
2254  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Pure
2255  Abv->Add(BitCodeAbbrevOp(0)); // HasInheritedProto
2256  Abv->Add(BitCodeAbbrevOp(1)); // HasWrittenProto
2257  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
2258  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
2259  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
2260  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
2261  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
2262  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
2263  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
2264  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
2265  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
2266  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
2267  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
2268  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
2269  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LocEnd
2270  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
2271  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind
2272  // This Array slurps the rest of the record. Fortunately we want to encode
2273  // (nearly) all the remaining (variable number of) fields in the same way.
2274  //
2275  // This is the function template information if any, then
2276  // NumParams and Params[] from FunctionDecl, and
2277  // NumOverriddenMethods, OverriddenMethods[] from CXXMethodDecl.
2278  //
2279  // Add an AbbrevOp for 'size then elements' and use it here.
2280  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
2281  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
2282  DeclCXXMethodAbbrev = Stream.EmitAbbrev(std::move(Abv));
2283 
2284  // Abbreviation for EXPR_DECL_REF
2285  Abv = std::make_shared<BitCodeAbbrev>();
2286  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_DECL_REF));
2287  //Stmt
2288  // Expr
2289  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2290  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2291  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2292  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2293  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2294  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ContainsErrors
2295  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2296  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2297  //DeclRefExpr
2298  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HasQualifier
2299  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //GetDeclFound
2300  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ExplicitTemplateArgs
2301  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //HadMultipleCandidates
2302  Abv->Add(BitCodeAbbrevOp(0)); // RefersToEnclosingVariableOrCapture
2303  Abv->Add(BitCodeAbbrevOp(0)); // NonOdrUseReason
2304  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // DeclRef
2305  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2306  DeclRefExprAbbrev = Stream.EmitAbbrev(std::move(Abv));
2307 
2308  // Abbreviation for EXPR_INTEGER_LITERAL
2309  Abv = std::make_shared<BitCodeAbbrev>();
2310  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_INTEGER_LITERAL));
2311  //Stmt
2312  // Expr
2313  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2314  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2315  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2316  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2317  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2318  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ContainsErrors
2319  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2320  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2321  //Integer Literal
2322  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2323  Abv->Add(BitCodeAbbrevOp(32)); // Bit Width
2324  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Value
2325  IntegerLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2326 
2327  // Abbreviation for EXPR_CHARACTER_LITERAL
2328  Abv = std::make_shared<BitCodeAbbrev>();
2329  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_CHARACTER_LITERAL));
2330  //Stmt
2331  // Expr
2332  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2333  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2334  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2335  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2336  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2337  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ContainsErrors
2338  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2339  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2340  //Character Literal
2341  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // getValue
2342  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Location
2343  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // getKind
2344  CharacterLiteralAbbrev = Stream.EmitAbbrev(std::move(Abv));
2345 
2346  // Abbreviation for EXPR_IMPLICIT_CAST
2347  Abv = std::make_shared<BitCodeAbbrev>();
2348  Abv->Add(BitCodeAbbrevOp(serialization::EXPR_IMPLICIT_CAST));
2349  // Stmt
2350  // Expr
2351  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
2352  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //TypeDependent
2353  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ValueDependent
2354  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //InstantiationDependent
2355  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //UnexpandedParamPack
2356  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); //ContainsErrors
2357  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetValueKind
2358  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); //GetObjectKind
2359  // CastExpr
2360  Abv->Add(BitCodeAbbrevOp(0)); // PathSize
2361  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // HasFPFeatures
2362  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 6)); // CastKind
2363  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // PartOfExplicitCast
2364  // ImplicitCastExpr
2365  ExprImplicitCastAbbrev = Stream.EmitAbbrev(std::move(Abv));
2366 
2367  Abv = std::make_shared<BitCodeAbbrev>();
2368  Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_LEXICAL));
2369  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2370  DeclContextLexicalAbbrev = Stream.EmitAbbrev(std::move(Abv));
2371 
2372  Abv = std::make_shared<BitCodeAbbrev>();
2373  Abv->Add(BitCodeAbbrevOp(serialization::DECL_CONTEXT_VISIBLE));
2374  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
2375  DeclContextVisibleLookupAbbrev = Stream.EmitAbbrev(std::move(Abv));
2376 }
2377 
2378 /// isRequiredDecl - Check if this is a "required" Decl, which must be seen by
2379 /// consumers of the AST.
2380 ///
2381 /// Such decls will always be deserialized from the AST file, so we would like
2382 /// this to be as restrictive as possible. Currently the predicate is driven by
2383 /// code generation requirements, if other clients have a different notion of
2384 /// what is "required" then we may have to consider an alternate scheme where
2385 /// clients can iterate over the top-level decls and get information on them,
2386 /// without necessary deserializing them. We could explicitly require such
2387 /// clients to use a separate API call to "realize" the decl. This should be
2388 /// relatively painless since they would presumably only do it for top-level
2389 /// decls.
2390 static bool isRequiredDecl(const Decl *D, ASTContext &Context,
2391  bool WritingModule) {
2392  // An ObjCMethodDecl is never considered as "required" because its
2393  // implementation container always is.
2394 
2395  // File scoped assembly or obj-c or OMP declare target implementation must be
2396  // seen.
2397  if (isa<FileScopeAsmDecl>(D) || isa<ObjCImplDecl>(D))
2398  return true;
2399 
2400  if (WritingModule && isPartOfPerModuleInitializer(D)) {
2401  // These declarations are part of the module initializer, and are emitted
2402  // if and when the module is imported, rather than being emitted eagerly.
2403  return false;
2404  }
2405 
2406  return Context.DeclMustBeEmitted(D);
2407 }
2408 
2409 void ASTWriter::WriteDecl(ASTContext &Context, Decl *D) {
2410  PrettyDeclStackTraceEntry CrashInfo(Context, D, SourceLocation(),
2411  "serializing");
2412 
2413  // Determine the ID for this declaration.
2415  assert(!D->isFromASTFile() && "should not be emitting imported decl");
2416  serialization::DeclID &IDR = DeclIDs[D];
2417  if (IDR == 0)
2418  IDR = NextDeclID++;
2419 
2420  ID = IDR;
2421 
2422  assert(ID >= FirstDeclID && "invalid decl ID");
2423 
2424  RecordData Record;
2425  ASTDeclWriter W(*this, Context, Record);
2426 
2427  // Build a record for this declaration
2428  W.Visit(D);
2429 
2430  // Emit this declaration to the bitstream.
2431  uint64_t Offset = W.Emit(D);
2432 
2433  // Record the offset for this declaration
2434  SourceLocation Loc = D->getLocation();
2435  unsigned Index = ID - FirstDeclID;
2436  if (DeclOffsets.size() == Index)
2437  DeclOffsets.emplace_back(Loc, Offset, DeclTypesBlockStartOffset);
2438  else if (DeclOffsets.size() < Index) {
2439  // FIXME: Can/should this happen?
2440  DeclOffsets.resize(Index+1);
2441  DeclOffsets[Index].setLocation(Loc);
2442  DeclOffsets[Index].setBitOffset(Offset, DeclTypesBlockStartOffset);
2443  } else {
2444  llvm_unreachable("declarations should be emitted in ID order");
2445  }
2446 
2447  SourceManager &SM = Context.getSourceManager();
2448  if (Loc.isValid() && SM.isLocalSourceLocation(Loc))
2449  associateDeclWithFile(D, ID);
2450 
2451  // Note declarations that should be deserialized eagerly so that we can add
2452  // them to a record in the AST file later.
2453  if (isRequiredDecl(D, Context, WritingModule))
2454  EagerlyDeserializedDecls.push_back(ID);
2455 }
2456 
2458  // Switch case IDs are per function body.
2459  Writer->ClearSwitchCaseIDs();
2460 
2461  assert(FD->doesThisDeclarationHaveABody());
2462  bool ModulesCodegen = false;
2463  if (!FD->isDependentContext()) {
2465  if (Writer->WritingModule &&
2466  Writer->WritingModule->Kind == Module::ModuleInterfaceUnit) {
2467  // When building a C++ Modules TS module interface unit, a strong
2468  // definition in the module interface is provided by the compilation of
2469  // that module interface unit, not by its users. (Inline functions are
2470  // still emitted in module users.)
2471  Linkage = Writer->Context->GetGVALinkageForFunction(FD);
2472  ModulesCodegen = *Linkage == GVA_StrongExternal;
2473  }
2474  if (Writer->Context->getLangOpts().ModulesCodegen ||
2475  (FD->hasAttr<DLLExportAttr>() &&
2476  Writer->Context->getLangOpts().BuildingPCHWithObjectFile)) {
2477 
2478  // Under -fmodules-codegen, codegen is performed for all non-internal,
2479  // non-always_inline functions, unless they are available elsewhere.
2480  if (!FD->hasAttr<AlwaysInlineAttr>()) {
2481  if (!Linkage)
2482  Linkage = Writer->Context->GetGVALinkageForFunction(FD);
2483  ModulesCodegen =
2485  }
2486  }
2487  }
2488  Record->push_back(ModulesCodegen);
2489  if (ModulesCodegen)
2490  Writer->ModularCodegenDecls.push_back(Writer->GetDeclRef(FD));
2491  if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
2492  Record->push_back(CD->getNumCtorInitializers());
2493  if (CD->getNumCtorInitializers())
2494  AddCXXCtorInitializers(
2495  llvm::makeArrayRef(CD->init_begin(), CD->init_end()));
2496  }
2497  AddStmt(FD->getBody());
2498 }
clang::serialization::DECL_CXX_METHOD
@ DECL_CXX_METHOD
A CXXMethodDecl record.
Definition: ASTBitCodes.h:1379
clang::DeclaratorDecl::getInnerLocStart
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:771
clang::ExplicitSpecifier
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1795
clang::serialization::EXPR_CHARACTER_LITERAL
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
Definition: ASTBitCodes.h:1604
clang::serialization::DECL_NAMESPACE
@ DECL_NAMESPACE
A NamespaceDecl record.
Definition: ASTBitCodes.h:1337
clang::VarTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2973
clang::TemplateDecl::getTemplatedDecl
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:431
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1148
clang::RecordDecl::hasFlexibleArrayMember
bool hasFlexibleArrayMember() const
Definition: Decl.h:3913
clang::CXXConstructorDecl::getExplicitSpecifier
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2475
clang::OMPAllocateDecl
This represents '#pragma omp allocate ...' directive.
Definition: DeclOpenMP.h:473
clang::EmptyDecl
Represents an empty-declaration.
Definition: Decl.h:4574
clang::UsingDirectiveDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:2927
clang::ASTDeclWriter::VisitObjCCategoryDecl
void VisitObjCCategoryDecl(ObjCCategoryDecl *D)
Definition: ASTWriterDecl.cpp:834
clang::ConceptDecl::getConstraintExpr
Expr * getConstraintExpr() const
Definition: DeclTemplate.h:3246
clang::serialization::DECL_OMP_DECLARE_MAPPER
@ DECL_OMP_DECLARE_MAPPER
An OMPDeclareMapperDecl record.
Definition: ASTBitCodes.h:1496
clang::OMPDeclareReductionDecl::getInitializer
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:239
clang::ASTDeclWriter::VisitFileScopeAsmDecl
void VisitFileScopeAsmDecl(FileScopeAsmDecl *D)
Definition: ASTWriterDecl.cpp:1151
clang::ObjCPropertyImplDecl::getPropertyIvarDecl
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2814
clang::FunctionDecl::doesThisDeclarationHaveABody
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2163
clang::ObjCCompatibleAliasDecl
ObjCCompatibleAliasDecl - Represents alias of a class.
Definition: DeclObjC.h:2711
clang::ASTDeclWriter::VisitDeclContext
void VisitDeclContext(DeclContext *DC)
Emit the DeclContext part of a declaration context decl.
Definition: ASTWriterDecl.cpp:1776
clang::ASTRecordWriter::AddFunctionDefinition
void AddFunctionDefinition(const FunctionDecl *FD)
Add a definition for the given function to the queue of statements to emit.
Definition: ASTWriterDecl.cpp:2457
clang::FunctionDecl::getDefaultedFunctionInfo
DefaultedFunctionInfo * getDefaultedFunctionInfo() const
Definition: Decl.cpp:2931
clang::serialization::DECL_CAPTURED
@ DECL_CAPTURED
A CapturedDecl record.
Definition: ASTBitCodes.h:1312
clang::AccessSpecDecl
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:87
clang::FunctionDecl::isDefaulted
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2215
clang::BlockDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:4239
clang::ASTDeclWriter::VisitClassTemplatePartialSpecializationDecl
void VisitClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl *D)
Definition: ASTWriterDecl.cpp:1572
clang::serialization::DECL_USING
@ DECL_USING
A UsingDecl record.
Definition: ASTBitCodes.h:1343
clang::serialization::DECL_PARM_VAR
@ DECL_PARM_VAR
A ParmVarDecl record.
Definition: ASTBitCodes.h:1297
clang::serialization::DECL_USING_SHADOW
@ DECL_USING_SHADOW
A UsingShadowDecl record.
Definition: ASTBitCodes.h:1352
clang::ObjCMethodDecl::hasRedeclaration
bool hasRedeclaration() const
True if redeclared in the same interface.
Definition: DeclObjC.h:274
llvm
Definition: Dominators.h:30
clang::FunctionDecl::hasWrittenPrototype
bool hasWrittenPrototype() const
Whether this function has a written prototype.
Definition: Decl.h:2261
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2401
clang::VarDecl::getStorageDuration
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
Definition: Decl.h:1146
clang::RecordDecl::hasVolatileMember
bool hasVolatileMember() const
Definition: Decl.h:3943
clang::ExportDecl::getRBraceLoc
SourceLocation getRBraceLoc() const
Definition: Decl.h:4546
clang::Decl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:422
clang::FriendTemplateDecl::getFriendLoc
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
Definition: DeclTemplate.h:2492
clang::ASTDeclWriter::VisitPragmaCommentDecl
void VisitPragmaCommentDecl(PragmaCommentDecl *D)
Definition: ASTWriterDecl.cpp:337
clang::BlockDecl::isVariadic
bool isVariadic() const
Definition: Decl.h:4228
clang::ObjCProtocolDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2105
clang::FriendTemplateDecl
Declaration of a friend template.
Definition: DeclTemplate.h:2440
clang::ASTDeclWriter::VisitUsingEnumDecl
void VisitUsingEnumDecl(UsingEnumDecl *D)
Definition: ASTWriterDecl.cpp:1282
clang::MSGuidDeclParts
Parts of a decomposed MSGuidDecl.
Definition: DeclCXX.h:4116
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6407
clang::TemplateTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1715
clang::RecordDecl::hasNonTrivialToPrimitiveCopyCUnion
bool hasNonTrivialToPrimitiveCopyCUnion() const
Definition: Decl.h:3998
clang::NamespaceDecl::getRBraceLoc
SourceLocation getRBraceLoc() const
Definition: Decl.h:658
clang::DependentFunctionTemplateSpecializationInfo
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:683
clang::serialization::DECL_UNRESOLVED_USING_IF_EXISTS
@ DECL_UNRESOLVED_USING_IF_EXISTS
An UnresolvedUsingIfExistsDecl record.
Definition: ASTBitCodes.h:1436
clang::NamespaceDecl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:657
clang::TemplateTypeParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1262
clang::serialization::EXPR_INTEGER_LITERAL
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
Definition: ASTBitCodes.h:1592
clang::VarDecl::isInlineSpecified
bool isInlineSpecified() const
Definition: Decl.h:1464
clang::MemberSpecializationInfo
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:619
clang::DeclarationName::Identifier
@ Identifier
Definition: DeclarationName.h:203
clang::ASTDeclWriter::VisitTypeAliasTemplateDecl
void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1761
clang::serialization::DECL_EMPTY
@ DECL_EMPTY
An EmptyDecl record.
Definition: ASTBitCodes.h:1475
clang::Decl::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:426
clang::serialization::DECL_FRIEND_TEMPLATE
@ DECL_FRIEND_TEMPLATE
A FriendTemplateDecl record.
Definition: ASTBitCodes.h:1397
clang::ObjCImplementationDecl::init_end
init_iterator init_end()
init_end() - Retrieve an iterator past the last initializer.
Definition: DeclObjC.h:2614
clang::FunctionDecl::TK_MemberSpecialization
@ TK_MemberSpecialization
Definition: Decl.h:1870
clang::RecordDecl::getArgPassingRestrictions
ArgPassingKind getArgPassingRestrictions() const
Definition: Decl.h:4013
clang::LinkageSpecDecl
Represents a linkage specification.
Definition: DeclCXX.h:2797
clang::DecompositionDecl::bindings
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4050
clang::serialization::DECL_TYPE_ALIAS_TEMPLATE
@ DECL_TYPE_ALIAS_TEMPLATE
A TypeAliasTemplateDecl record.
Definition: ASTBitCodes.h:1430
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1347
clang::serialization::DECL_DECOMPOSITION
@ DECL_DECOMPOSITION
A DecompositionDecl record.
Definition: ASTBitCodes.h:1300
clang::FunctionDecl::TK_FunctionTemplate
@ TK_FunctionTemplate
Definition: Decl.h:1867
clang::CXXConversionDecl
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2731
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:547
clang::Redeclarable
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:84
clang::ObjCPropertyImplDecl::getSetterCXXAssignment
Expr * getSetterCXXAssignment() const
Definition: DeclObjC.h:2850
clang::ObjCPropertyDecl::getGetterMethodDecl
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:898
clang::CXXRecordDecl::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
Definition: DeclCXX.cpp:1795
clang::NamespaceAliasDecl
Represents a C++ namespace alias.
Definition: DeclCXX.h:2986
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2536
clang::ASTDeclWriter::VisitTagDecl
void VisitTagDecl(TagDecl *D)
Definition: ASTWriterDecl.cpp:409
clang::ClassTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2128
clang::serialization::DECL_USING_PACK
@ DECL_USING_PACK
A UsingPackDecl record.
Definition: ASTBitCodes.h:1349
clang::FunctionTemplateSpecializationInfo::TemplateArguments
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:484
clang::serialization::DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION
@ DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION
A ClassScopeFunctionSpecializationDecl record a class scope function specialization.
Definition: ASTBitCodes.h:1460
clang::MSPropertyDecl::getGetterId
IdentifierInfo * getGetterId() const
Definition: DeclCXX.h:4109
clang::Decl::isOutOfLine
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
clang::ASTDeclWriter::VisitUnresolvedUsingTypenameDecl
void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D)
Definition: ASTWriterDecl.cpp:1339
clang::ASTDeclWriter::VisitMSPropertyDecl
void VisitMSPropertyDecl(MSPropertyDecl *D)
Definition: ASTWriterDecl.cpp:952
clang::UsingDirectiveDecl
Represents C++ using-directive.
Definition: DeclCXX.h:2882
clang::ObjCImplementationDecl::init_begin
init_iterator init_begin()
init_begin() - Retrieve an iterator to the first initializer.
Definition: DeclObjC.h:2605
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3959
clang::serialization::DECL_OMP_THREADPRIVATE
@ DECL_OMP_THREADPRIVATE
An OMPThreadPrivateDecl record.
Definition: ASTBitCodes.h:1466
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::OMPThreadPrivateDecl
This represents '#pragma omp threadprivate ...' directive.
Definition: DeclOpenMP.h:110
clang::serialization::DECL_PRAGMA_COMMENT
@ DECL_PRAGMA_COMMENT
A PragmaCommentDecl record.
Definition: ASTBitCodes.h:1490
clang::ASTDeclWriter::VisitCXXDeductionGuideDecl
void VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D)
Definition: ASTWriterDecl.cpp:675
clang::VarTemplateSpecializationDecl::getTemplateInstantiationArgs
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate the initializer of the vari...
Definition: DeclTemplate.h:2834
clang::VarDecl::isInitCapture
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1488
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:249
clang::DeclContext::getPrimaryContext
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1229
clang::ASTDeclWriter::VisitCapturedDecl
void VisitCapturedDecl(CapturedDecl *D)
Definition: ASTWriterDecl.cpp:1203
clang::OMPDeclareReductionDecl::getInitPriv
Expr * getInitPriv()
Get Priv variable of the initializer.
Definition: DeclOpenMP.h:249
clang::ClassTemplateSpecializationDecl::getPointOfInstantiation
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
Definition: DeclTemplate.h:1936
clang::EnumDecl::getIntegerTypeSourceInfo
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
Definition: Decl.h:3762
clang::ClassTemplateSpecializationDecl::getSpecializedTemplate
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Definition: DeclTemplate.cpp:963
clang::ASTRecordWriter::push_back
void push_back(uint64_t N)
Minimal vector-like interface.
Definition: ASTRecordWriter.h:76
clang::ClassTemplateSpecializationDecl::getExternLoc
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Definition: DeclTemplate.h:2026
clang::ASTWriter::getFirstLocalDecl
const Decl * getFirstLocalDecl(const Decl *D)
Find the first local declaration of a given local redeclarable decl.
Definition: ASTWriterDecl.cpp:1781
clang::ConceptReference::getNamedConcept
ConceptDecl * getNamedConcept() const
Definition: ASTConcept.h:154
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::TypeDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: Decl.h:3162
clang::EnumDecl::isFixed
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3795
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1380
Attr.h
clang::FileScopeAsmDecl::getRParenLoc
SourceLocation getRParenLoc() const
Definition: Decl.h:4136
clang::TypedefNameDecl::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:3230
clang::TypeConstraint::getImmediatelyDeclaredConstraint
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
Definition: ASTConcept.h:187
clang::ASTDeclWriter::VisitNamespaceDecl
void VisitNamespaceDecl(NamespaceDecl *D)
Definition: ASTWriterDecl.cpp:1235
clang::ClassScopeFunctionSpecializationDecl::hasExplicitTemplateArgs
bool hasExplicitTemplateArgs() const
Definition: DeclTemplate.h:2620
clang::CapturedDecl::getNumParams
unsigned getNumParams() const
Definition: Decl.h:4387
clang::ObjCIvarDecl::getAccessControl
AccessControl getAccessControl() const
Definition: DeclObjC.h:1960
clang::serialization::DECL_USING_ENUM
@ DECL_USING_ENUM
A UsingEnumDecl record.
Definition: ASTBitCodes.h:1346
clang::ClassScopeFunctionSpecializationDecl
Declaration of a function specialization at template class scope.
Definition: DeclTemplate.h:2600
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2835
clang::ASTDeclWriter::VisitVarDecl
void VisitVarDecl(VarDecl *D)
Definition: ASTWriterDecl.cpp:985
clang::ClassTemplateSpecializationDecl::getSpecializationKind
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
Definition: DeclTemplate.h:1897
clang::UnresolvedUsingTypenameDecl::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Definition: DeclCXX.h:3862
clang::FieldDecl::getInClassInitializer
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.h:2982
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1665
clang::Redeclarable::getFirstDecl
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:216
DeclCXX.h
clang::ObjCPropertyImplDecl::getGetterMethodDecl
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:2836
clang::ObjCCategoryDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.h:2309
clang::Decl::isUsed
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition: DeclBase.cpp:443
clang::EnumDecl::getODRHash
unsigned getODRHash()
Definition: Decl.cpp:4494
clang::serialization::DECL_CONSTRUCTOR_USING_SHADOW
@ DECL_CONSTRUCTOR_USING_SHADOW
A ConstructorUsingShadowDecl record.
Definition: ASTBitCodes.h:1355
clang::DependentFunctionTemplateSpecializationInfo::getTemplateArg
const TemplateArgumentLoc & getTemplateArg(unsigned I) const
Returns the nth template argument.
Definition: DeclTemplate.h:733
clang::ASTDeclWriter::AddObjCTypeParamList
void AddObjCTypeParamList(ObjCTypeParamList *typeParams)
Add an Objective-C type parameter list to the given record.
Definition: ASTWriterDecl.cpp:161
clang::FunctionDecl::TK_FunctionTemplateSpecialization
@ TK_FunctionTemplateSpecialization
Definition: Decl.h:1874
clang::DependentFunctionTemplateSpecializationInfo::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Returns the number of explicit template arguments that were given.
Definition: DeclTemplate.h:730
clang::ASTContext::getInstantiatedFromUsingEnumDecl
UsingEnumDecl * getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst)
If the given using-enum decl Inst is an instantiation of another using-enum decl, return it.
Definition: ASTContext.cpp:1584
clang::EnumConstantDecl::getInitExpr
const Expr * getInitExpr() const
Definition: Decl.h:3069
clang::TemplateSubstitutionKind::Specialization
@ Specialization
We are substituting template parameters for template arguments in order to form a template specializa...
clang::UsingShadowDecl
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3187
clang::ASTDeclWriter::VisitVarTemplatePartialSpecializationDecl
void VisitVarTemplatePartialSpecializationDecl(VarTemplatePartialSpecializationDecl *D)
Definition: ASTWriterDecl.cpp:1632
clang::ASTDeclWriter::VisitFunctionTemplateDecl
void VisitFunctionTemplateDecl(FunctionTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1659
clang::ASTDeclWriter::VisitOMPDeclareReductionDecl
void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D)
Definition: ASTWriterDecl.cpp:1875
clang::NonTypeTemplateParmDecl::getExpansionType
QualType getExpansionType(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
Definition: DeclTemplate.h:1540
clang::Decl::getIdentifierNamespace
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:814
clang::ASTDeclWriter::VisitNamedDecl
void VisitNamedDecl(NamedDecl *D)
Definition: ASTWriterDecl.cpp:363
clang::BlockDecl::getBody
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.h:4232
clang::FunctionDecl::getTemplateSpecializationInfo
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3800
clang::FunctionDecl::hasImplicitReturnZero
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:2241
clang::ObjCPropertyImplDecl
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2741
clang::ASTDeclWriter::VisitVarTemplateSpecializationDecl
void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D)
Definition: ASTWriterDecl.cpp:1596
clang::ParmVarDecl::getObjCDeclQualifier
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1729
clang::MSGuidDecl::getParts
Parts getParts() const
Get the decomposed parts of this declaration.
Definition: DeclCXX.h:4170
clang::serialization::DECL_IMPLICIT_PARAM
@ DECL_IMPLICIT_PARAM
An ImplicitParamDecl record.
Definition: ASTBitCodes.h:1294
llvm::Optional
Definition: LLVM.h:40
clang::ComparisonCategoryType::First
@ First
clang::ASTContext::getObjCMethodRedeclaration
const ObjCMethodDecl * getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const
Get the duplicate declaration of a ObjCMethod in the same interface, or null if none exists.
Definition: ASTContext.cpp:2895
clang::TagDecl::isEmbeddedInDeclarator
bool isEmbeddedInDeclarator() const
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
Definition: Decl.h:3457
clang::serialization::DECL_UNRESOLVED_USING_TYPENAME
@ DECL_UNRESOLVED_USING_TYPENAME
An UnresolvedUsingTypenameDecl record.
Definition: ASTBitCodes.h:1364
SourceManager.h
clang::NonTypeTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1459
clang::UnresolvedUsingTypenameDecl::getTypenameLoc
SourceLocation getTypenameLoc() const
Returns the source location of the 'typename' keyword.
Definition: DeclCXX.h:3841
clang::VarTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Definition: DeclTemplate.h:2751
clang::ASTDeclWriter::VisitDecl
void VisitDecl(Decl *D)
Definition: ASTWriterDecl.cpp:298
clang::TagDecl::getTypedefNameForAnonDecl
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3538
clang::serialization::DECL_CLASS_TEMPLATE
@ DECL_CLASS_TEMPLATE
A ClassTemplateDecl record.
Definition: ASTBitCodes.h:1400
clang::ASTDeclWriter::VisitTypeAliasDecl
void VisitTypeAliasDecl(TypeAliasDecl *D)
Definition: ASTWriterDecl.cpp:403
clang::serialization::DECL_OBJC_PROPERTY_IMPL
@ DECL_OBJC_PROPERTY_IMPL
A ObjCPropertyImplDecl record.
Definition: ASTBitCodes.h:1276
clang::ObjCPropertyImplDecl::getPropertyIvarDeclLoc
SourceLocation getPropertyIvarDeclLoc() const
Definition: DeclObjC.h:2817
clang::IndirectFieldDecl::getChainingSize
unsigned getChainingSize() const
Definition: Decl.h:3117
clang::ClassTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2071
clang::UsingPackDecl
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Definition: DeclCXX.h:3644
clang::CXXDestructorDecl::getOperatorDelete
const FunctionDecl * getOperatorDelete() const
Definition: DeclCXX.h:2701
clang::ExportDecl
Represents a C++ Modules TS module export declaration.
Definition: Decl.h:4527
clang::ObjCPropertyDecl::getPropertyImplementation
PropertyControl getPropertyImplementation() const
Definition: DeclObjC.h:909
clang::ASTDeclWriter::VisitEnumDecl
void VisitEnumDecl(EnumDecl *D)
Definition: ASTWriterDecl.cpp:433
clang::RedeclarableTemplateDecl
Declaration of a redeclarable template.
Definition: DeclTemplate.h:748
clang::MSGuidDeclParts::Part1
uint32_t Part1
{01234567-...
Definition: DeclCXX.h:4118
clang::serialization::DECL_REQUIRES_EXPR_BODY
@ DECL_REQUIRES_EXPR_BODY
A RequiresExprBodyDecl record.
Definition: ASTBitCodes.h:1481
clang::FunctionDecl::isInlineSpecified
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2591
clang::ASTContext::getCurrentKeyFunction
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
Definition: RecordLayoutBuilder.cpp:3338
clang::ASTTemplateArgumentListInfo::NumTemplateArgs
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: TemplateBase.h:630
clang::LifetimeExtendedTemporaryDecl::getManglingNumber
unsigned getManglingNumber() const
Definition: DeclCXX.h:3145
clang::VarTemplateSpecializationDecl
Represents a variable template specialization, which refers to a variable template with a given set o...
Definition: DeclTemplate.h:2660
clang::Decl::isTopLevelDeclInObjCContainer
bool isTopLevelDeclInObjCContainer() const
Whether this declaration is a top-level declaration (function, global variable, etc....
Definition: DeclBase.h:598
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4342
clang::serialization::DECL_FIELD
@ DECL_FIELD
A FieldDecl record.
Definition: ASTBitCodes.h:1279
clang::serialization::DECL_TYPEALIAS
@ DECL_TYPEALIAS
A TypeAliasDecl record.
Definition: ASTBitCodes.h:1231
clang::FunctionDecl::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
Definition: Decl.cpp:3668
clang::ASTDeclWriter::VisitClassScopeFunctionSpecializationDecl
void VisitClassScopeFunctionSpecializationDecl(ClassScopeFunctionSpecializationDecl *D)
Definition: ASTWriterDecl.cpp:1648
clang::ASTDeclWriter::VisitObjCImplementationDecl
void VisitObjCImplementationDecl(ObjCImplementationDecl *D)
Definition: ASTWriterDecl.cpp:888
clang::AccessSpecDecl::getColonLoc
SourceLocation getColonLoc() const
The location of the colon following the access specifier.
Definition: DeclCXX.h:109
clang::ObjCMethodDecl::isOverriding
bool isOverriding() const
Whether this method overrides any other in the class hierarchy.
Definition: DeclObjC.h:467
clang::FunctionDecl::param_size
size_t param_size() const
Definition: Decl.h:2499
clang::serialization::isPartOfPerModuleInitializer
bool isPartOfPerModuleInitializer(const Decl *D)
Determine whether the given declaration will be included in the per-module initializer if it needs to...
Definition: ASTCommon.h:116
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:694
clang::RecordDecl::isNonTrivialToPrimitiveDestroy
bool isNonTrivialToPrimitiveDestroy() const
Definition: Decl.h:3974
clang::TemplateTypeParmDecl::hasTypeConstraint
bool hasTypeConstraint() const
Determine whether this template parameter has a type-constraint.
Definition: DeclTemplate.h:1354
clang::Decl::isReferenced
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:468
clang::serialization::DECL_RECORD
@ DECL_RECORD
A RecordDecl record.
Definition: ASTBitCodes.h:1237
clang::serialization::DECL_FUNCTION_TEMPLATE
@ DECL_FUNCTION_TEMPLATE
A FunctionTemplateDecl record.
Definition: ASTBitCodes.h:1418
clang::serialization::DECL_OBJC_INTERFACE
@ DECL_OBJC_INTERFACE
A ObjCInterfaceDecl record.
Definition: ASTBitCodes.h:1249
clang::ASTDeclWriter::VisitObjCImplDecl
void VisitObjCImplDecl(ObjCImplDecl *D)
Definition: ASTWriterDecl.cpp:876
clang::EnumDecl::getNumPositiveBits
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
Definition: Decl.h:3772
clang::OMPDeclareReductionDecl::getCombinerOut
Expr * getCombinerOut()
Get Out variable of the combiner.
Definition: DeclOpenMP.h:227
clang::TemplateTypeParmDecl::getDefaultArgumentInfo
TypeSourceInfo * getDefaultArgumentInfo() const
Retrieves the default argument's source information, if any.
Definition: DeclTemplate.h:1253
clang::ObjCImplDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2424
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::EnumDecl
Represents an enum.
Definition: Decl.h:3590
clang::serialization::DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
@ DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION
A ClassTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1406
clang::FieldDecl::hasCapturedVLAType
bool hasCapturedVLAType() const
Determine whether this member captures the variable length array type.
Definition: Decl.h:3008
clang::ASTDeclWriter::VisitFriendDecl
void VisitFriendDecl(FriendDecl *D)
Definition: ASTWriterDecl.cpp:1462
clang::VarTemplatePartialSpecializationDecl::getInstantiatedFromMember
VarTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member variable template partial specialization from which this particular variable temp...
Definition: DeclTemplate.h:3016
clang::ASTDeclWriter::AddTemplateSpecializations
void AddTemplateSpecializations(DeclTy *D)
Definition: ASTWriterDecl.cpp:209
clang::ASTDeclWriter::VisitUsingPackDecl
void VisitUsingPackDecl(UsingPackDecl *D)
Definition: ASTWriterDecl.cpp:1292
clang::UsingShadowDecl::getTargetDecl
NamedDecl * getTargetDecl() const
Gets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3251
clang::FunctionDecl::isInlined
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2613
clang::FunctionTemplateSpecializationInfo::getTemplate
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:526
clang::TemplateTypeParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1245
clang::ASTDeclWriter::getSpecializationDecl
RedeclarableTemplateDecl::SpecEntryTraits< EntryType >::DeclType * getSpecializationDecl(EntryType &T)
Get the specialization decl from an entry in the specialization list.
Definition: ASTWriterDecl.cpp:195
clang::ASTDeclWriter::VisitFunctionDecl
void VisitFunctionDecl(FunctionDecl *D)
Definition: ASTWriterDecl.cpp:540
clang::FunctionDecl::isVirtualAsWritten
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2181
Offset
unsigned Offset
Definition: Format.cpp:2335
clang::ASTDeclWriter::VisitImportDecl
void VisitImportDecl(ImportDecl *D)
Definition: ASTWriterDecl.cpp:1438
clang::serialization::DECL_CXX_RECORD
@ DECL_CXX_RECORD
A CXXRecordDecl record.
Definition: ASTBitCodes.h:1373
clang::PragmaCommentDecl::getCommentKind
PragmaMSCommentKind getCommentKind() const
Definition: Decl.h:163
clang::AS_none
@ AS_none
Definition: Specifiers.h:103
clang::ObjCInterfaceDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Determine whether this particular declaration of this class is actually also a definition.
Definition: DeclObjC.h:1506
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:4280
clang::OMPDeclareMapperDecl::getVarName
DeclarationName getVarName()
Get the name of the variable declared in the mapper.
Definition: DeclOpenMP.h:359
clang::BlockDecl::doesNotEscape
bool doesNotEscape() const
Definition: Decl.h:4304
clang::serialization::needsAnonymousDeclarationNumber
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:448
clang::CXXRecordDecl::getDescribedClassTemplate
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1809
clang::FunctionDecl::getODRHash
unsigned getODRHash()
Returns ODRHash of the function.
Definition: Decl.cpp:4123
clang::UnresolvedUsingTypenameDecl
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3809
clang::ASTRecordWriter::AddStmt
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
Definition: ASTRecordWriter.h:119
clang::ASTDeclWriter::VisitTemplateTypeParmDecl
void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D)
Definition: ASTWriterDecl.cpp:1667
clang::CXXRecordDecl::classofKind
static bool classofKind(Kind K)
Definition: DeclCXX.h:1787
clang::Decl::getLexicalDeclContext
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:843
clang::VarDecl::isInline
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1461
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:974
clang::ASTDeclWriter::VisitDeclaratorDecl
void VisitDeclaratorDecl(DeclaratorDecl *D)
Definition: ASTWriterDecl.cpp:526
clang::serialization::DECL_FILE_SCOPE_ASM
@ DECL_FILE_SCOPE_ASM
A FileScopeAsmDecl record.
Definition: ASTBitCodes.h:1306
clang::serialization::DECL_OBJC_COMPATIBLE_ALIAS
@ DECL_OBJC_COMPATIBLE_ALIAS
A ObjCCompatibleAliasDecl record.
Definition: ASTBitCodes.h:1270
clang::TemplateTypeParmDecl::isExpandedParameterPack
bool isExpandedParameterPack() const
Whether this parameter is a template type parameter pack that has a known list of different type-cons...
Definition: DeclTemplate.h:1332
clang::ObjCPropertyImplDecl::getSetterMethodDecl
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:2839
clang::FunctionTemplateSpecializationInfo::getPointOfInstantiation
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this function template specialization.
Definition: DeclTemplate.h:557
clang::ObjCProtocolDecl::protocol_size
unsigned protocol_size() const
Definition: DeclObjC.h:2144
clang::ClassTemplatePartialSpecializationDecl::getInstantiatedFromMember
ClassTemplatePartialSpecializationDecl * getInstantiatedFromMember() const
Retrieve the member class template partial specialization from which this particular class template p...
Definition: DeclTemplate.h:2171
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1152
clang::VarTemplateSpecializationDecl::getTemplateKeywordLoc
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
Definition: DeclTemplate.h:2897
clang::TranslationUnitDecl
The top declaration context.
Definition: Decl.h:82
clang::NonTypeTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1469
clang::ConceptReference::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: ASTConcept.h:158
clang::FunctionDecl::getConstexprKind
ConstexprSpecKind getConstexprKind() const
Definition: Decl.h:2289
clang::ObjCMethodDecl::hasRelatedResultType
bool hasRelatedResultType() const
Determine whether this method has a result type that is related to the message receiver's type.
Definition: DeclObjC.h:259
clang::serialization::DECL_TEMPLATE_TEMPLATE_PARM
@ DECL_TEMPLATE_TEMPLATE_PARM
A TemplateTemplateParmDecl record.
Definition: ASTBitCodes.h:1427
clang::OMPDeclareMapperDecl::getPrevDeclInScope
OMPDeclareMapperDecl * getPrevDeclInScope()
Get reference to previous declare mapper construct in the same scope with the same name.
Definition: DeclOpenMP.cpp:158
clang::VarTemplatePartialSpecializationDecl::isMemberSpecialization
bool isMemberSpecialization()
Determines whether this variable template partial specialization was a specialization of a member par...
Definition: DeclTemplate.h:3044
clang::CXXMethodDecl::overridden_methods
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2429
clang::ClassTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Definition: DeclTemplate.h:1887
DeclTemplate.h
clang::FunctionDecl::hasSkippedBody
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
Definition: Decl.h:2425
clang::ASTDeclWriter::VisitRedeclarableTemplateDecl
void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1512
clang::OMPDeclareReductionDecl
This represents '#pragma omp declare reduction ...' directive.
Definition: DeclOpenMP.h:171
clang::RequiresExprBodyDecl
Represents the body of a requires-expression.
Definition: DeclCXX.h:1926
clang::Linkage
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:23
clang::ImportDecl
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4447
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:478
clang::ASTDeclWriter::VisitFieldDecl
void VisitFieldDecl(FieldDecl *D)
Definition: ASTWriterDecl.cpp:916
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2207
clang::UsingEnumDecl::getUsingLoc
SourceLocation getUsingLoc() const
The source location of the 'using' keyword.
Definition: DeclCXX.h:3601
clang::RecordDecl::hasNonTrivialToPrimitiveDestructCUnion
bool hasNonTrivialToPrimitiveDestructCUnion() const
Definition: Decl.h:3990
clang::ASTDeclWriter::Visit
void Visit(Decl *D)
Definition: ASTWriterDecl.cpp:271
clang::ObjCImplementationDecl::getSuperClassLoc
SourceLocation getSuperClassLoc() const
Definition: DeclObjC.h:2673
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4153
clang::ASTDeclWriter::VisitObjCIvarDecl
void VisitObjCIvarDecl(ObjCIvarDecl *D)
Definition: ASTWriterDecl.cpp:792
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:433
clang::ObjCMethodDecl::isDefined
bool isDefined() const
Definition: DeclObjC.h:457
clang::FunctionDecl::getTemplatedKind
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3645
clang::TypedefNameDecl::isModed
bool isModed() const
Definition: Decl.h:3226
clang::NonTypeTemplateParmDecl::getNumExpansionTypes
unsigned getNumExpansionTypes() const
Retrieves the number of expansion types in an expanded parameter pack.
Definition: DeclTemplate.h:1533
clang::ObjCInterfaceDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:1342
ASTCommon.h
clang::ConceptDecl
Declaration of a C++2a concept.
Definition: DeclTemplate.h:3231
clang::serialization::DECL_VAR_TEMPLATE_SPECIALIZATION
@ DECL_VAR_TEMPLATE_SPECIALIZATION
A VarTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1412
clang::OMPDeclareReductionDecl::getPrevDeclInScope
OMPDeclareReductionDecl * getPrevDeclInScope()
Get reference to previous declare reduction construct in the same scope with the same name.
Definition: DeclOpenMP.cpp:126
clang::serialization::DECL_CXX_DEDUCTION_GUIDE
@ DECL_CXX_DEDUCTION_GUIDE
A CXXDeductionGuideDecl record.
Definition: ASTBitCodes.h:1376
clang::Module::ModuleInterfaceUnit
@ ModuleInterfaceUnit
This is a C++ Modules TS module interface unit.
Definition: Module.h:110
clang::ASTDeclWriter::VisitUnresolvedUsingValueDecl
void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D)
Definition: ASTWriterDecl.cpp:1330
clang::VarDecl::isObjCForDecl
bool isObjCForDecl() const
Determine whether this variable is a for-loop declaration for a for-in statement in Objective-C.
Definition: Decl.h:1442
PrettyDeclStackTrace.h
clang::TemplateTemplateParmDecl::getPosition
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
Definition: DeclTemplate.h:1161
clang::CXXDeductionGuideDecl::isCopyDeductionCandidate
bool isCopyDeductionCandidate() const
Definition: DeclCXX.h:1904
clang::ObjCImplementationDecl::hasDestructors
bool hasDestructors() const
Do any of the ivars of this class (not counting its base classes) require non-trivial destruction?
Definition: DeclObjC.h:2643
clang::DeclAccessPair
A POD class for pairing a NamedDecl* with an access specifier.
Definition: DeclAccessPair.h:29
clang::VarDecl::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Definition: Decl.cpp:2689
clang::ASTDeclWriter::VisitObjCCategoryImplDecl
void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D)
Definition: ASTWriterDecl.cpp:882
clang::serialization::DECL_CXX_DESTRUCTOR
@ DECL_CXX_DESTRUCTOR
A CXXDestructorDecl record.
Definition: ASTBitCodes.h:1385
clang::FieldDecl::getBitWidth
Expr * getBitWidth() const
Definition: Decl.h:2924
clang::ASTDeclWriter::VisitMSGuidDecl
void VisitMSGuidDecl(MSGuidDecl *D)
Definition: ASTWriterDecl.cpp:959
clang::ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: DeclTemplate.h:2621
clang::VarDecl::isStaticDataMember
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1200
clang::FunctionTemplateDecl::Common
Data that is common to all of the declarations of a given function template.
Definition: DeclTemplate.h:980
clang::TemplateTemplateParmDecl::getExpansionTemplateParameters
TemplateParameterList * getExpansionTemplateParameters(unsigned I) const
Retrieve a particular expansion type within an expanded parameter pack.
Definition: DeclTemplate.h:1706
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:211
clang::FriendDecl::getFriendDecl
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
Definition: DeclFriend.h:138
clang::VarTemplatePartialSpecializationDecl::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
Definition: DeclTemplate.h:2978
clang::ObjCPropertyDecl::getSetterMethodDecl
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:901
clang::ASTDeclWriter::VisitOMPThreadPrivateDecl
void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D)
Definition: ASTWriterDecl.cpp:1857
clang::NamespaceAliasDecl::getNamespaceLoc
SourceLocation getNamespaceLoc() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:3075
clang::DecompositionDecl
A decomposition declaration.
Definition: DeclCXX.h:4016
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:3015
clang::FunctionTemplateDecl::getCanonicalDecl
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:1044
clang::StaticAssertDecl::getRParenLoc
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:3941
clang::ASTDeclWriter::getPartialSpecializations
decltype(T::PartialSpecializations) & getPartialSpecializations(T *Common)
Get the list of partial specializations from a template's common ptr.
Definition: ASTWriterDecl.cpp:201
clang::ASTDeclWriter::VisitTypeDecl
void VisitTypeDecl(TypeDecl *D)
Definition: ASTWriterDecl.cpp:371
clang::serialization::DECL_OBJC_CATEGORY
@ DECL_OBJC_CATEGORY
A ObjCCategoryDecl record.
Definition: ASTBitCodes.h:1261
clang::UnresolvedUsingTypenameDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3845
clang::ASTRecordWriter::AddSourceLocation
void AddSourceLocation(SourceLocation Loc)
Emit a source location.
Definition: ASTRecordWriter.h:131
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:558
clang::ASTDeclWriter::VisitRedeclarable
void VisitRedeclarable(Redeclarable< T > *D)
Definition: ASTWriterDecl.cpp:1799
clang::serialization::DECL_OBJC_AT_DEFS_FIELD
@ DECL_OBJC_AT_DEFS_FIELD
A ObjCAtDefsFieldDecl record.
Definition: ASTBitCodes.h:1258
clang::ObjCPropertyDecl::getSetterName
Selector getSetterName() const
Definition: DeclObjC.h:890
clang::serialization::EXPR_IMPLICIT_CAST
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1643
clang::ASTDeclWriter::VisitValueDecl
void VisitValueDecl(ValueDecl *D)
Definition: ASTWriterDecl.cpp:511
clang::serialization::DECL_LINKAGE_SPEC
@ DECL_LINKAGE_SPEC
A LinkageSpecDecl record.
Definition: ASTBitCodes.h:1367
clang::ASTDeclWriter::VisitExportDecl
void VisitExportDecl(ExportDecl *D)
Definition: ASTWriterDecl.cpp:1222
clang::serialization::DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
@ DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION
A VarTemplatePartialSpecializationDecl record.
Definition: ASTBitCodes.h:1415
clang::VarDecl::isEscapingByref
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2533
clang::ObjCPropertyImplDecl::getGetterCXXConstructor
Expr * getGetterCXXConstructor() const
Definition: DeclObjC.h:2842
clang::serialization::DECL_CLASS_TEMPLATE_SPECIALIZATION
@ DECL_CLASS_TEMPLATE_SPECIALIZATION
A ClassTemplateSpecializationDecl record.
Definition: ASTBitCodes.h:1403
clang::TagDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Return true if this declaration is a completion definition of the type.
Definition: Decl.h:3428
clang::StaticAssertDecl::getMessage
StringLiteral * getMessage()
Definition: DeclCXX.h:3936
clang::VarDecl::isNRVOVariable
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO).
Definition: Decl.h:1422
clang::LabelDecl
Represents the declaration of a label.
Definition: Decl.h:496
clang::ObjCMethodDecl::getSelfDecl
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:423
clang::FriendTemplateDecl::getTemplateParameterList
TemplateParameterList * getTemplateParameterList(unsigned i) const
Definition: DeclTemplate.h:2496
clang::serialization::DECL_VAR_TEMPLATE
@ DECL_VAR_TEMPLATE
A VarTemplateDecl record.
Definition: ASTBitCodes.h:1409
clang::Decl::getCanonicalDecl
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:901
clang::UsingDecl::getUsingLoc
SourceLocation getUsingLoc() const
Return the source location of the 'using' keyword.
Definition: DeclCXX.h:3406
clang::EnumDecl::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
Definition: Decl.h:3840
clang::MSPropertyDecl::getSetterId
IdentifierInfo * getSetterId() const
Definition: DeclCXX.h:4111
clang::ASTDeclWriter::VisitCXXRecordDecl
void VisitCXXRecordDecl(CXXRecordDecl *D)
Definition: ASTWriterDecl.cpp:1354
clang::EnumConstantDecl::getInitVal
const llvm::APSInt & getInitVal() const
Definition: Decl.h:3071
clang::MSGuidDecl
A global _GUID constant.
Definition: DeclCXX.h:4139
clang::TypedefNameDecl::getUnderlyingType
QualType getUnderlyingType() const
Definition: Decl.h:3235
clang::ObjCIvarDecl::getSynthesize
bool getSynthesize() const
Definition: DeclObjC.h:1967
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2668
clang::ObjCInterfaceDecl::getCategoryListRaw
ObjCCategoryDecl * getCategoryListRaw() const
Retrieve the raw pointer to the start of the category/extension list.
Definition: DeclObjC.h:1760
isRequiredDecl
static bool isRequiredDecl(const Decl *D, ASTContext &Context, bool WritingModule)
isRequiredDecl - Check if this is a "required" Decl, which must be seen by consumers of the AST.
Definition: ASTWriterDecl.cpp:2390
clang::ASTDeclWriter::VisitRequiresExprBodyDecl
void VisitRequiresExprBodyDecl(RequiresExprBodyDecl *D)
Definition: ASTWriterDecl.cpp:1508
clang::EnumDecl::getMostRecentDecl
EnumDecl * getMostRecentDecl()
Definition: Decl.h:3686
clang::Decl::isModulePrivate
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
Definition: DeclBase.h:612
clang::ImplicitParamDecl
Definition: Decl.h:1601
clang::ASTDeclWriter::VisitCXXConversionDecl
void VisitCXXConversionDecl(CXXConversionDecl *D)
Definition: ASTWriterDecl.cpp:1432
clang::FieldDecl::hasInClassInitializer
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2975
Expr.h
clang::FriendTemplateDecl::getFriendDecl
NamedDecl * getFriendDecl() const
If this friend declaration names a templated function (or a member function of a templated type),...
Definition: DeclTemplate.h:2487
clang::ASTDeclWriter::VisitLifetimeExtendedTemporaryDecl
void VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D)
Definition: ASTWriterDecl.cpp:1163
clang::FriendDecl
FriendDecl - Represents the declaration of a friend entity, which can be a function,...
Definition: DeclFriend.h:53
clang::TemplateTemplateParmDecl
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Definition: DeclTemplate.h:1597
clang::TypeDecl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:3165
clang::TemplateTemplateParmDecl::getNumExpansionTemplateParameters
unsigned getNumExpansionTemplateParameters() const
Retrieves the number of expansion template parameters in an expanded parameter pack.
Definition: DeclTemplate.h:1699
clang::serialization::DECL_OBJC_PROPERTY
@ DECL_OBJC_PROPERTY
A ObjCPropertyDecl record.
Definition: ASTBitCodes.h:1273
clang::ObjCMethodDecl::hasSkippedBody
bool hasSkippedBody() const
True if the method was a definition but its body was skipped.
Definition: DeclObjC.h:482
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
clang::ObjCMethodDecl::getReturnType
QualType getReturnType() const
Definition: DeclObjC.h:332
clang::serialization::DECL_OMP_REQUIRES
@ DECL_OMP_REQUIRES
An OMPRequiresDecl record.
Definition: ASTBitCodes.h:1469
clang::ASTDeclWriter::VisitTranslationUnitDecl
void VisitTranslationUnitDecl(TranslationUnitDecl *D)
Definition: ASTWriterDecl.cpp:359
clang::serialization::DECL_CXX_CONVERSION
@ DECL_CXX_CONVERSION
A CXXConversionDecl record.
Definition: ASTBitCodes.h:1388
clang::EnumDecl::getPromotionType
QualType getPromotionType() const
Return the integer type that enumerators should promote to.
Definition: Decl.h:3738
clang::serialization::DECL_USING_DIRECTIVE
@ DECL_USING_DIRECTIVE
A UsingDirecitveDecl record.
Definition: ASTBitCodes.h:1358
clang::ASTRecordWriter::size
size_t size() const
Definition: ASTRecordWriter.h:82
clang::TagDecl
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3328
clang::OMPDeclareMapperDecl
This represents '#pragma omp declare mapper ...' directive.
Definition: DeclOpenMP.h:286
clang::PragmaCommentDecl::getArg
StringRef getArg() const
Definition: Decl.h:165
clang::UsingDirectiveDecl::getNamespaceKeyLocation
SourceLocation getNamespaceKeyLocation() const
Returns the location of the namespace keyword.
Definition: DeclCXX.h:2957
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Definition: DeclObjC.h:2483
clang::serialization::DECL_ENUM
@ DECL_ENUM
An EnumDecl record.
Definition: ASTBitCodes.h:1234
clang::TypeDecl
Represents a declaration of a type.
Definition: Decl.h:3138
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1753
clang::NamedDecl::isModulePrivate
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined.
Definition: DeclBase.h:612
clang::serialization::DECL_STATIC_ASSERT
@ DECL_STATIC_ASSERT
A StaticAssertDecl record.
Definition: ASTBitCodes.h:1439
clang::DependentFunctionTemplateSpecializationInfo::getNumTemplates
unsigned getNumTemplates() const
Returns the number of function templates that this might be a specialization of.
Definition: DeclTemplate.h:716
clang::ImportDecl::getIdentifierLocs
ArrayRef< SourceLocation > getIdentifierLocs() const
Retrieves the locations of each of the identifiers that make up the complete module name in the impor...
Definition: Decl.cpp:5123
clang::ASTDeclWriter::VisitConstructorUsingShadowDecl
void VisitConstructorUsingShadowDecl(ConstructorUsingShadowDecl *D)
Definition: ASTWriterDecl.cpp:1311
clang::serialization::DECL_OBJC_TYPE_PARAM
@ DECL_OBJC_TYPE_PARAM
An ObjCTypeParamDecl record.
Definition: ASTBitCodes.h:1484
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3050
clang::serialization::DECL_MS_GUID
@ DECL_MS_GUID
A MSGuidDecl record.
Definition: ASTBitCodes.h:1285
clang::CapturedDecl::getParam
ImplicitParamDecl * getParam(unsigned i) const
Definition: Decl.h:4389
clang::ObjCMethodDecl::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclObjC.cpp:996
clang::ObjCAtDefsFieldDecl::classofKind
static bool classofKind(Kind K)
Definition: DeclObjC.h:2008
clang::ASTDeclWriter::VisitFriendTemplateDecl
void VisitFriendTemplateDecl(FriendTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1481
clang::Redeclarable::getPreviousDecl
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:204
clang::ObjCMethodDecl::getReturnTypeSourceInfo
TypeSourceInfo * getReturnTypeSourceInfo() const
Definition: DeclObjC.h:346
clang::serialization::DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
@ DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK
A TemplateTemplateParmDecl record that stores an expanded template template parameter pack.
Definition: ASTBitCodes.h:1456
clang::OMPDeclareReductionDecl::getCombinerIn
Expr * getCombinerIn()
Get In variable of the combiner.
Definition: DeclOpenMP.h:224
clang::EnumDecl::isScopedUsingClassTag
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3789
clang::BlockVarCopyInit
Copy initialization expr of a __block variable and a boolean flag that indicates whether the expressi...
Definition: Expr.h:6011
clang::ASTWriter
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:99
clang::ClassTemplateSpecializationDecl::getTemplateInstantiationArgs
const TemplateArgumentList & getTemplateInstantiationArgs() const
Retrieve the set of template arguments that should be used to instantiate members of the class templa...
Definition: DeclTemplate.h:1982
clang::RecordDecl::isParamDestroyedInCallee
bool isParamDestroyedInCallee() const
Definition: Decl.h:4021
clang::UnresolvedUsingValueDecl
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3713
clang::ObjCPropertyDecl::getType
QualType getType() const
Definition: DeclObjC.h:801
clang::Redeclarable::isFirstDecl
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: Redeclarable.h:223
clang::TagDecl::isCompleteDefinition
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3433
clang::ObjCImplementationDecl::getIvarLBraceLoc
SourceLocation getIvarLBraceLoc() const
Definition: DeclObjC.h:2678
clang::ASTDeclWriter::VisitObjCMethodDecl
void VisitObjCMethodDecl(ObjCMethodDecl *D)
Definition: ASTWriterDecl.cpp:683
clang::ASTDeclWriter::VisitIndirectFieldDecl
void VisitIndirectFieldDecl(IndirectFieldDecl *D)
Definition: ASTWriterDecl.cpp:976
clang::NamespaceDecl::isOriginalNamespace
bool isOriginalNamespace() const
Return true if this declaration is an original (first) declaration of the namespace.
Definition: DeclCXX.cpp:2886
clang::ASTDeclWriter::VisitEnumConstantDecl
void VisitEnumConstantDecl(EnumConstantDecl *D)
Definition: ASTWriterDecl.cpp:516
clang::serialization::EXPR_DECL_REF
@ EXPR_DECL_REF
A DeclRefExpr record.
Definition: ASTBitCodes.h:1589
clang::TemplateTypeParmDecl
Declaration of a template type parameter.
Definition: DeclTemplate.h:1174
clang::ParmVarDecl::getFunctionScopeDepth
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1715
clang::RecordDecl::isAnonymousStructOrUnion
bool isAnonymousStructOrUnion() const
Whether this is an anonymous struct or union.
Definition: Decl.h:3932
clang::ClassTemplateSpecializationDecl::getSpecializedTemplateOrPartial
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this.
Definition: DeclTemplate.h:1963
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:563
clang::TemplateParamObjectDecl
A template parameter object.
Definition: DeclTemplate.h:3283
clang::ASTContext::getInstantiatedFromUsingDecl
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
Definition: ASTContext.cpp:1561
clang::ObjCImplementationDecl::getSuperClass
const ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.h:2671
clang::Decl::getOwningModule
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:773
clang::FieldDecl::isMutable
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2910
clang::MemberSpecializationInfo::getPointOfInstantiation
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:659
clang::StaticAssertDecl::isFailed
bool isFailed() const
Definition: DeclCXX.h:3939
clang::RecordDecl::isNonTrivialToPrimitiveCopy
bool isNonTrivialToPrimitiveCopy() const
Definition: Decl.h:3966
clang::FieldDecl::getCapturedVLAType
const VariableArrayType * getCapturedVLAType() const
Get the captured variable length array type.
Definition: Decl.h:3013
clang::serialization::DECL_OBJC_IMPLEMENTATION
@ DECL_OBJC_IMPLEMENTATION
A ObjCImplementationDecl record.
Definition: ASTBitCodes.h:1267
clang::TemplateDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:418
clang::UsingDecl
Represents a C++ using-declaration.
Definition: DeclCXX.h:3379
clang::GVA_Internal
@ GVA_Internal
Definition: Linkage.h:74
clang::NamedDecl::getMostRecentDecl
NamedDecl * getMostRecentDecl()
Definition: Decl.h:473
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2264
clang::serialization::DECL_FRIEND
@ DECL_FRIEND
A FriendDecl record.
Definition: ASTBitCodes.h:1394
clang::VarDecl::getDescribedVarTemplate
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2645
clang::ClassTemplateSpecializationDecl::getTypeAsWritten
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
Definition: DeclTemplate.h:2021
clang::serialization::DECL_OBJC_PROTOCOL
@ DECL_OBJC_PROTOCOL
A ObjCProtocolDecl record.
Definition: ASTBitCodes.h:1252
clang::VarTemplateSpecializationDecl::getPointOfInstantiation
SourceLocation getPointOfInstantiation() const
Get the point of instantiation (if any), or null if none.
Definition: DeclTemplate.h:2788
clang::CXXDeductionGuideDecl::getExplicitSpecifier
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:1883
clang::serialization::DECL_BLOCK
@ DECL_BLOCK
A BlockDecl record.
Definition: ASTBitCodes.h:1309
clang::serialization::DECL_OMP_DECLARE_REDUCTION
@ DECL_OMP_DECLARE_REDUCTION
An OMPDeclareReductionDecl record.
Definition: ASTBitCodes.h:1499
clang::ExplicitSpecifier::getExpr
const Expr * getExpr() const
Definition: DeclCXX.h:1804
clang::VarDecl::isThisDeclarationADemotedDefinition
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
Definition: Decl.h:1386
clang::VarTemplateDecl::getCanonicalDecl
VarTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:3150
clang::TemplateTypeParmDecl::wasDeclaredWithTypename
bool wasDeclaredWithTypename() const
Whether this template type parameter was declared with the 'typename' keyword.
Definition: DeclTemplate.h:1237
clang::RedeclarableTemplateDecl::SpecEntryTraits::getDecl
static DeclType * getDecl(EntryType *D)
Definition: DeclTemplate.h:770
clang::ParmVarDecl::getUninstantiatedDefaultArg
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:2828
clang::UnresolvedUsingValueDecl::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Get the location of the ellipsis if this is a pack expansion.
Definition: DeclCXX.h:3772
clang::ASTDeclWriter::VisitObjCPropertyImplDecl
void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D)
Definition: ASTWriterDecl.cpp:903
clang::ASTDeclWriter::VisitObjCAtDefsFieldDecl
void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D)
Definition: ASTWriterDecl.cpp:829
clang::FriendTemplateDecl::getFriendType
TypeSourceInfo * getFriendType() const
If this friend declaration names a templated type (or a dependent member type of a templated type),...
Definition: DeclTemplate.h:2480
clang::ObjCMethodDecl::getObjCDeclQualifier
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:249
clang::StaticAssertDecl::getAssertExpr
Expr * getAssertExpr()
Definition: DeclCXX.h:3933
clang::NamespaceAliasDecl::getNamespace
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3059
clang::serialization::DeclCode
DeclCode
Record codes for each kind of declaration.
Definition: ASTBitCodes.h:1226
clang::ASTDeclWriter::ASTDeclWriter
ASTDeclWriter(ASTWriter &Writer, ASTContext &Context, ASTWriter::RecordDataImpl &Record)
Definition: ASTWriterDecl.cpp:43
clang::UsingEnumDecl
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3579
clang::UsingPackDecl::getInstantiatedFromUsingDecl
NamedDecl * getInstantiatedFromUsingDecl() const
Get the using declaration from which this was instantiated.
Definition: DeclCXX.h:3676
clang::TemplateTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template.
Definition: DeclTemplate.h:1728
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
clang::serialization::UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION
@ UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION
Definition: ASTCommon.h:26
clang::LinkageSpecDecl::getLanguage
LanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Definition: DeclCXX.h:2826
clang::serialization::DECL_EXPORT
@ DECL_EXPORT
An ExportDecl record.
Definition: ASTBitCodes.h:1370
clang::DeclContext::getRedeclContext
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1780
clang::ObjCCategoryImplDecl::getCategoryNameLoc
SourceLocation getCategoryNameLoc() const
Definition: DeclObjC.h:2511
clang::ASTDeclWriter::VisitOMPAllocateDecl
void VisitOMPAllocateDecl(OMPAllocateDecl *D)
Definition: ASTWriterDecl.cpp:1863
clang::declvisitor::Base< std::add_pointer, ImplClass, void >::Visit
void Visit(PTR(Decl) D)
Definition: DeclVisitor.h:37
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::ObjCContainerDecl::getAtStartLoc
SourceLocation getAtStartLoc() const
Definition: DeclObjC.h:1091
clang::TypedefNameDecl::getAnonDeclWithTypedefName
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
Definition: Decl.cpp:4971
clang::ClassTemplatePartialSpecializationDecl::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Get the template arguments as written.
Definition: DeclTemplate.h:2147
clang::ASTDeclWriter::VisitObjCInterfaceDecl
void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D)
Definition: ASTWriterDecl.cpp:748
clang::serialization::DECL_OBJC_METHOD
@ DECL_OBJC_METHOD
A ObjCMethodDecl record.
Definition: ASTBitCodes.h:1246
clang::FunctionDecl::usesSEHTry
bool usesSEHTry() const
Indicates the function uses __try.
Definition: Decl.h:2316
clang::ASTDeclWriter::VisitEmptyDecl
void VisitEmptyDecl(EmptyDecl *D)
Definition: ASTWriterDecl.cpp:1158
clang::ASTDeclWriter::VisitTemplateParamObjectDecl
void VisitTemplateParamObjectDecl(TemplateParamObjectDecl *D)
Definition: ASTWriterDecl.cpp:970
clang::Decl::getPreviousDecl
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:984
clang::ObjCPropertyImplDecl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclObjC.h:2802
clang::FunctionTemplateSpecializationInfo
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:467
clang::NonTypeTemplateParmDecl::getExpansionTypeSourceInfo
TypeSourceInfo * getExpansionTypeSourceInfo(unsigned I) const
Retrieve a particular expansion type source info within an expanded parameter pack.
Definition: DeclTemplate.h:1549
clang::EnumDecl::isScoped
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3786
clang::ASTDeclWriter::VisitImplicitParamDecl
void VisitImplicitParamDecl(ImplicitParamDecl *D)
Definition: ASTWriterDecl.cpp:1083
clang::ObjCCategoryDecl::protocol_locs
protocol_loc_range protocol_locs() const
Definition: DeclObjC.h:2354
clang::Decl::hasAttrs
bool hasAttrs() const
Definition: DeclBase.h:489
clang::TagDecl::getBraceRange
SourceRange getBraceRange() const
Definition: Decl.h:3409
clang::CXXMethodDecl::size_overridden_methods
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2423
clang::ASTRecordWriter::append
void append(InputIterator begin, InputIterator end)
Definition: ASTRecordWriter.h:78
clang::Decl::isFromASTFile
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:716
clang::NonTypeTemplateParmDecl::getDefaultArgument
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1462
clang::TemplateTypeParmDecl::getTypeConstraint
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
Definition: DeclTemplate.h:1342
clang::ASTDeclWriter::VisitBlockDecl
void VisitBlockDecl(BlockDecl *D)
Definition: ASTWriterDecl.cpp:1174
clang::ASTDeclWriter::VisitDecompositionDecl
void VisitDecompositionDecl(DecompositionDecl *D)
Definition: ASTWriterDecl.cpp:1135
clang::ASTDeclWriter::VisitTypedefNameDecl
void VisitTypedefNameDecl(TypedefNameDecl *D)
Definition: ASTWriterDecl.cpp:377
clang::StaticAssertDecl
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3910
clang::TagDecl::isFreeStanding
bool isFreeStanding() const
True if this tag is free standing, e.g. "struct foo;".
Definition: Decl.h:3468
clang::serialization::DECL_OMP_ALLOCATE
@ DECL_OMP_ALLOCATE
An OMPAllocateDcl record.
Definition: ASTBitCodes.h:1472
clang::ASTTemplateArgumentListInfo::LAngleLoc
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
Definition: TemplateBase.h:624
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2243
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:676
clang::serialization::DECL_VAR
@ DECL_VAR
A VarDecl record.
Definition: ASTBitCodes.h:1291
clang::DependentFunctionTemplateSpecializationInfo::getRAngleLoc
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:742
clang::VarDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1085
clang::ASTDeclWriter::VisitClassTemplateSpecializationDecl
void VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D)
Definition: ASTWriterDecl.cpp:1536
clang::serialization::DECL_ACCESS_SPEC
@ DECL_ACCESS_SPEC
An AccessSpecDecl record.
Definition: ASTBitCodes.h:1391
clang::serialization::DECL_UNRESOLVED_USING_VALUE
@ DECL_UNRESOLVED_USING_VALUE
An UnresolvedUsingValueDecl record.
Definition: ASTBitCodes.h:1361
clang::OMPCapturedExprDecl
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:383
clang::ASTDeclWriter::VisitLabelDecl
void VisitLabelDecl(LabelDecl *LD)
Definition: ASTWriterDecl.cpp:1228
clang::ObjCImplDecl
Definition: DeclObjC.h:2409
clang::FunctionDecl::isMultiVersion
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition: Decl.h:2435
clang::OMPDeclareReductionDecl::getInitOrig
Expr * getInitOrig()
Get Orig variable of the initializer.
Definition: DeclOpenMP.h:246
clang::ObjCPropertyDecl::getLParenLoc
SourceLocation getLParenLoc() const
Definition: DeclObjC.h:796
clang::LifetimeExtendedTemporaryDecl::getValue
APValue * getValue() const
Definition: DeclCXX.h:3151
clang::serialization::DECL_TEMPLATE_PARAM_OBJECT
@ DECL_TEMPLATE_PARAM_OBJECT
A TemplateParamObjectDecl record.
Definition: ASTBitCodes.h:1288
clang::serialization::LOCAL_REDECLARATIONS
const unsigned int LOCAL_REDECLARATIONS
Record code for a list of local redeclarations of a declaration.
Definition: ASTBitCodes.h:1218
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1860
clang::ObjCCategoryDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2340
clang::ObjCCompatibleAliasDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2729
clang::serialization::DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK
@ DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK
A NonTypeTemplateParmDecl record that stores an expanded non-type template parameter pack.
Definition: ASTBitCodes.h:1452
clang::ObjCInterfaceDecl::protocol_locs
protocol_loc_range protocol_locs() const
Definition: DeclObjC.h:1371
clang::ParmVarDecl::isObjCMethodParameter
bool isObjCMethodParameter() const
Definition: Decl.h:1708
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
clang::NonTypeTemplateParmDecl::isExpandedParameterPack
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
Definition: DeclTemplate.h:1529
clang::VarTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2921
clang::ObjCMethodDecl::isSynthesizedAccessorStub
bool isSynthesizedAccessorStub() const
Definition: DeclObjC.h:449
llvm::ArrayRef
Definition: LLVM.h:34
DeclVisitor.h
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::MSGuidDeclParts::Part2
uint16_t Part2
...-89ab-...
Definition: DeclCXX.h:4120
clang::PrettyDeclStackTraceEntry
PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a decl...
Definition: PrettyDeclStackTrace.h:30
clang::ASTDeclWriter::VisitNamespaceAliasDecl
void VisitNamespaceAliasDecl(NamespaceAliasDecl *D)
Definition: ASTWriterDecl.cpp:1261
clang::ObjCPropertyDecl::getPropertyIvarDecl
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:921
clang::ParmVarDecl::getFunctionScopeIndex
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1725
OpenMPClause.h
clang::DeclaratorDecl
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:728
clang::FunctionDecl::isPure
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2190
clang::NamespaceAliasDecl::getTargetNameLoc
SourceLocation getTargetNameLoc() const
Returns the location of the identifier in the named namespace.
Definition: DeclCXX.h:3078
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:729
clang::UsingDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3413
clang::ASTDeclWriter::VisitAccessSpecDecl
void VisitAccessSpecDecl(AccessSpecDecl *D)
Definition: ASTWriterDecl.cpp:1456
clang::CXXConstructorDecl::getInheritedConstructor
InheritedConstructor getInheritedConstructor() const
Get the constructor that this inheriting constructor is based on.
Definition: DeclCXX.h:2641
clang::ObjCMethodDecl::isInstanceMethod
bool isInstanceMethod() const
Definition: DeclObjC.h:431
clang::ASTDeclWriter::VisitClassTemplateDecl
void VisitClassTemplateDecl(ClassTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1528
clang::FunctionDecl::isTrivialForCall
bool isTrivialForCall() const
Definition: Decl.h:2210
clang::ClassScopeFunctionSpecializationDecl::getSpecialization
CXXMethodDecl * getSpecialization() const
Definition: DeclTemplate.h:2619
clang::ASTDeclWriter::VisitCXXMethodDecl
void VisitCXXMethodDecl(CXXMethodDecl *D)
Definition: ASTWriterDecl.cpp:1385
clang::CapturedDecl::isNothrow
bool isNothrow() const
Definition: Decl.cpp:4911
clang::FunctionDecl::TK_NonTemplate
@ TK_NonTemplate
Definition: Decl.h:1865
clang::SD_Static
@ SD_Static
Static storage duration.
Definition: Specifiers.h:301
clang::NamedDecl::getLinkageInternal
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
Definition: Decl.cpp:1116
clang::UnresolvedUsingValueDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3755
clang::ObjCTypeParamList::size
unsigned size() const
Determine the number of type parameters in this list.
Definition: DeclObjC.h:685
clang::NonTypeTemplateParmDecl::getDepth
unsigned getDepth() const
Get the nesting depth of the template parameter.
Definition: DeclTemplate.h:1157
clang::NamespaceAliasDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name of the namespace, with source-location inf...
Definition: DeclCXX.h:3050
clang::CXXRecordDecl::getPreviousDecl
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:502
clang::ObjCPropertyDecl::getGetterNameLoc
SourceLocation getGetterNameLoc() const
Definition: DeclObjC.h:883
clang::ASTDeclWriter::VisitStaticAssertDecl
void VisitStaticAssertDecl(StaticAssertDecl *D)
Definition: ASTWriterDecl.cpp:1766
clang::ClassTemplateDecl::getCanonicalDecl
ClassTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
Definition: DeclTemplate.h:2320
clang::DependentFunctionTemplateSpecializationInfo::getTemplate
FunctionTemplateDecl * getTemplate(unsigned I) const
Returns the i'th template candidate.
Definition: DeclTemplate.h:719
clang::ObjCCategoryDecl::getIvarLBraceLoc
SourceLocation getIvarLBraceLoc() const
Definition: DeclObjC.h:2401
clang::serialization::DECL_ENUM_CONSTANT
@ DECL_ENUM_CONSTANT
An EnumConstantDecl record.
Definition: ASTBitCodes.h:1240
clang::PragmaCommentDecl
Represents a #pragma comment line.
Definition: Decl.h:140
clang::CXXConversionDecl::getExplicitSpecifier
ExplicitSpecifier getExplicitSpecifier()
Definition: DeclCXX.h:2758
clang::ASTDeclWriter::RegisterTemplateSpecialization
void RegisterTemplateSpecialization(const Decl *Template, const Decl *Specialization)
Ensure that this template specialization is associated with the specified template on reload.
Definition: ASTWriterDecl.cpp:249
clang::serialization::DECL_MS_PROPERTY
@ DECL_MS_PROPERTY
A MSPropertyDecl record.
Definition: ASTBitCodes.h:1282
clang::CapturedDecl::getContextParamPosition
unsigned getContextParamPosition() const
Definition: Decl.h:4416
clang::UsingDirectiveDecl::getCommonAncestor
DeclContext * getCommonAncestor()
Returns the common ancestor context of this using-directive and its nominated namespace.
Definition: DeclCXX.h:2949
clang::serialization::DECL_OBJC_CATEGORY_IMPL
@ DECL_OBJC_CATEGORY_IMPL
A ObjCCategoryImplDecl record.
Definition: ASTBitCodes.h:1264
clang::ASTDeclWriter::VisitObjCCompatibleAliasDecl
void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D)
Definition: ASTWriterDecl.cpp:849
clang::serialization::DECL_CONCEPT
@ DECL_CONCEPT
A ConceptDecl record.
Definition: ASTBitCodes.h:1433
clang::RecordDecl::hasObjectMember
bool hasObjectMember() const
Definition: Decl.h:3940
clang::ASTRecordWriter
An object for streaming information to a record.
Definition: ASTRecordWriter.h:26
clang::ObjCImplementationDecl::getIvarRBraceLoc
SourceLocation getIvarRBraceLoc() const
Definition: DeclObjC.h:2680
clang::Redeclarable::getMostRecentDecl
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
clang::ObjCImplementationDecl::hasNonZeroConstructors
bool hasNonZeroConstructors() const
Do any of the ivars of this class (not counting its base classes) require construction other than zer...
Definition: DeclObjC.h:2638
clang::ObjCAtDefsFieldDecl
Represents a field declaration created by an @defs(...).
Definition: DeclObjC.h:1988
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1285
clang::VarTemplateSpecializationDecl::getExternLoc
SourceLocation getExternLoc() const
Gets the location of the extern keyword, if present.
Definition: DeclTemplate.h:2878
clang::ASTDeclWriter::VisitOMPRequiresDecl
void VisitOMPRequiresDecl(OMPRequiresDecl *D)
Definition: ASTWriterDecl.cpp:1869
clang::RecordDecl::hasNonTrivialToPrimitiveDefaultInitializeCUnion
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Definition: Decl.h:3982
clang::ASTDeclWriter::VisitObjCPropertyDecl
void VisitObjCPropertyDecl(ObjCPropertyDecl *D)
Definition: ASTWriterDecl.cpp:855
clang::serialization::DECL_TYPEDEF
@ DECL_TYPEDEF
A TypedefDecl record.
Definition: ASTBitCodes.h:1228
clang::TypedefDecl
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition: Decl.h:3282
clang::LinkageSpecDecl::getRBraceLoc
SourceLocation getRBraceLoc() const
Definition: DeclCXX.h:2841
clang::serialization::isRedeclarableDeclKind
bool isRedeclarableDeclKind(unsigned Kind)
Determine whether the given declaration kind is redeclarable.
Definition: ASTCommon.cpp:347
ASTRecordWriter.h
clang::ASTDeclWriter::VisitParmVarDecl
void VisitParmVarDecl(ParmVarDecl *D)
Definition: ASTWriterDecl.cpp:1088
clang::OMPDeclareReductionDecl::getCombiner
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:221
clang::ObjCPropertyImplDecl::getPropertyDecl
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2805
clang::MemberSpecializationInfo::getInstantiatedFrom
NamedDecl * getInstantiatedFrom() const
Retrieve the member declaration from which this member was instantiated.
Definition: DeclTemplate.h:638
clang::VarDecl::isPreviousDeclInSameBlockScope
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration's previous declaration was declared in the same block ...
Definition: Decl.h:1502
clang::VarTemplateSpecializationDecl::getSpecializedTemplateOrPartial
llvm::PointerUnion< VarTemplateDecl *, VarTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the variable template or variable template partial specialization which was specialized by t...
Definition: DeclTemplate.h:2815
clang::VarDecl::getTSCSpec
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1094
clang::ObjCPropertyDecl::getPropertyAttributesAsWritten
ObjCPropertyAttribute::Kind getPropertyAttributesAsWritten() const
Definition: DeclObjC.h:824
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::LifetimeExtendedTemporaryDecl::getTemporaryExpr
Expr * getTemporaryExpr()
Retrieve the expression to which the temporary materialization conversion was applied.
Definition: DeclCXX.h:3142
clang::LinkageSpecDecl::getExternLoc
SourceLocation getExternLoc() const
Definition: DeclCXX.h:2840
clang::ObjCTypeParamDecl
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:579
clang::ObjCPropertyDecl::getGetterName
Selector getGetterName() const
Definition: DeclObjC.h:882
clang::ObjCPropertyDecl::getSetterNameLoc
SourceLocation getSetterNameLoc() const
Definition: DeclObjC.h:891
clang::VarDecl::isARCPseudoStrong
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
Definition: Decl.h:1457
clang::ObjCMethodDecl::getBody
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:858
clang::ASTDeclWriter::VisitObjCProtocolDecl
void VisitObjCProtocolDecl(ObjCProtocolDecl *D)
Definition: ASTWriterDecl.cpp:813
clang::VarDecl::isCXXForRangeDecl
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement.
Definition: Decl.h:1432
clang::ASTRecordWriter::AddDeclRef
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
Definition: ASTRecordWriter.h:220
clang::NamespaceDecl::isAnonymousNamespace
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition: Decl.h:598
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
clang::ASTDeclWriter::VisitConceptDecl
void VisitConceptDecl(ConceptDecl *D)
Definition: ASTWriterDecl.cpp:1502
clang::serialization::DECL_FUNCTION
@ DECL_FUNCTION
A FunctionDecl record.
Definition: ASTBitCodes.h:1243
clang::CXXDeductionGuideDecl
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1850
clang::serialization::DECL_INDIRECTFIELD
@ DECL_INDIRECTFIELD
A IndirectFieldDecl record.
Definition: ASTBitCodes.h:1448
clang::OMPDeclareReductionDecl::getInitializerKind
InitKind getInitializerKind() const
Get initializer kind.
Definition: DeclOpenMP.h:242
clang::FileScopeAsmDecl
Definition: Decl.h:4118
clang::ObjCInterfaceDecl::getEndOfDefinitionLoc
SourceLocation getEndOfDefinitionLoc() const
Definition: DeclObjC.h:1854
clang::FunctionDecl::isLateTemplateParsed
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:2194
clang::ObjCMethodDecl::getCmdDecl
ImplicitParamDecl * getCmdDecl() const
Definition: DeclObjC.h:425
clang::VarDecl::CInit
@ CInit
C-style initialization with assignment.
Definition: Decl.h:881
clang::UnresolvedUsingValueDecl::getUsingLoc
SourceLocation getUsingLoc() const
Returns the source location of the 'using' keyword.
Definition: DeclCXX.h:3745
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:384
clang::ASTDeclWriter::VisitOMPDeclareMapperDecl
void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D)
Definition: ASTWriterDecl.cpp:1889
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::ObjCTypeParamList
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:657
clang::TemplateTemplateParmDecl::getDefaultArgument
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1718
clang
Definition: CalledOnceCheck.h:17
clang::IndirectFieldDecl
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3089
clang::TemplateTypeParmDecl::getNumExpansionParameters
unsigned getNumExpansionParameters() const
Retrieves the number of parameters in an expanded parameter pack.
Definition: DeclTemplate.h:1335
clang::GVA_StrongExternal
@ GVA_StrongExternal
Definition: Linkage.h:77
clang::ASTRecordWriter::Emit
uint64_t Emit(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, followed by its substatements, and return its offset.
Definition: ASTRecordWriter.h:89
clang::ObjCPropertyDecl::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: DeclObjC.h:799
clang::MSGuidDeclParts::Part4And5
uint8_t Part4And5[8]
...-0123-456789abcdef}
Definition: DeclCXX.h:4124
clang::serialization::DECL_TEMPLATE_TYPE_PARM
@ DECL_TEMPLATE_TYPE_PARM
A TemplateTypeParmDecl record.
Definition: ASTBitCodes.h:1421
clang::FileScopeAsmDecl::getAsmString
const StringLiteral * getAsmString() const
Definition: Decl.h:4142
clang::ASTDeclWriter::getPartialSpecializations
ArrayRef< Decl > getPartialSpecializations(FunctionTemplateDecl::Common *)
Definition: ASTWriterDecl.cpp:204
clang::TypeAliasDecl::getDescribedAliasTemplate
TypeAliasTemplateDecl * getDescribedAliasTemplate() const
Definition: Decl.h:3319
clang::GVA_AvailableExternally
@ GVA_AvailableExternally
Definition: Linkage.h:75
clang::ObjCInterfaceDecl::getSuperClassTInfo
TypeSourceInfo * getSuperClassTInfo() const
Definition: DeclObjC.h:1549
clang::NonTypeTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
Definition: DeclTemplate.h:1494
clang::EnumDecl::getNumNegativeBits
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:3783
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1921
clang::ParmVarDecl::isKNRPromoted
bool isKNRPromoted() const
True if the value passed to this parameter must undergo K&R-style default argument promotion:
Definition: Decl.h:1746
clang::VarDecl::isConstexpr
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1479
ASTReader.h
clang::ObjCCategoryDecl::getIvarRBraceLoc
SourceLocation getIvarRBraceLoc() const
Definition: DeclObjC.h:2403
clang::MSPropertyDecl
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4087
clang::UsingDecl::hasTypename
bool hasTypename() const
Return true if the using declaration has 'typename'.
Definition: DeclCXX.h:3428
clang::ParmVarDecl::hasUninstantiatedDefaultArg
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1786
clang::DeclVisitor
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:66
clang::ASTDeclWriter::VisitRecordDecl
void VisitRecordDecl(RecordDecl *D)
Definition: ASTWriterDecl.cpp:476
clang::serialization::DECL_LIFETIME_EXTENDED_TEMPORARY
@ DECL_LIFETIME_EXTENDED_TEMPORARY
An LifetimeExtendedTemporaryDecl record.
Definition: ASTBitCodes.h:1478
clang::ASTDeclWriter::VisitTemplateTemplateParmDecl
void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D)
Definition: ASTWriterDecl.cpp:1732
clang::TemplateTemplateParmDecl::isExpandedParameterPack
bool isExpandedParameterPack() const
Whether this parameter is a template template parameter pack that has a known list of different templ...
Definition: DeclTemplate.h:1695
clang::EnumDecl::getIntegerType
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3746
clang::ASTDeclWriter::VisitUsingDirectiveDecl
void VisitUsingDirectiveDecl(UsingDirectiveDecl *D)
Definition: ASTWriterDecl.cpp:1320
clang::TagDecl::isCompleteDefinitionRequired
bool isCompleteDefinitionRequired() const
Return true if this complete decl is required to be complete for some existing use.
Definition: Decl.h:3442
clang::RecordDecl::isNonTrivialToPrimitiveDefaultInitialize
bool isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C structs.
Definition: Decl.h:3958
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2040
clang::CXXMethodDecl::getMostRecentDecl
CXXMethodDecl * getMostRecentDecl()
Definition: DeclCXX.h:2040
clang::RecordDecl::getMostRecentDecl
RecordDecl * getMostRecentDecl()
Definition: Decl.h:3906
clang::serialization::DECL_CXX_CONSTRUCTOR
@ DECL_CXX_CONSTRUCTOR
A CXXConstructorDecl record.
Definition: ASTBitCodes.h:1382
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:112
clang::MSGuidDeclParts::Part3
uint16_t Part3
...-cdef-...
Definition: DeclCXX.h:4122
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:313
clang::UsingDirectiveDecl::getUsingLoc
SourceLocation getUsingLoc() const
Return the location of the using keyword.
Definition: DeclCXX.h:2953
clang::ClassTemplatePartialSpecializationDecl::isMemberSpecialization
bool isMemberSpecialization()
Determines whether this class template partial specialization template was a specialization of a memb...
Definition: DeclTemplate.h:2203
clang::OMPRequiresDecl
This represents '#pragma omp requires...' directive.
Definition: DeclOpenMP.h:416
clang::RedeclarableTemplateDecl::getInstantiatedFromMemberTemplate
RedeclarableTemplateDecl * getInstantiatedFromMemberTemplate() const
Retrieve the member template from which this template was instantiated, or nullptr if this template w...
Definition: DeclTemplate.h:932
clang::PragmaDetectMismatchDecl::getName
StringRef getName() const
Definition: Decl.h:197
clang::ObjCProtocolDecl::protocol_locs
protocol_loc_range protocol_locs() const
Definition: DeclObjC.h:2126
clang::DeclContext::isDependentContext
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1142
clang::ASTDeclWriter::VisitPragmaDetectMismatchDecl
void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D)
Definition: ASTWriterDecl.cpp:347
clang::ASTDeclWriter::VisitCXXDestructorDecl
void VisitCXXDestructorDecl(CXXDestructorDecl *D)
Definition: ASTWriterDecl.cpp:1422
clang::serialization::DECL_OMP_CAPTUREDEXPR
@ DECL_OMP_CAPTUREDEXPR
An OMPCapturedExprDecl record.
Definition: ASTBitCodes.h:1487
clang::NonTypeTemplateParmDecl::getPlaceholderTypeConstraint
Expr * getPlaceholderTypeConstraint() const
Return the constraint introduced by the placeholder type of this non-type template parameter (if any)...
Definition: DeclTemplate.h:1558
clang::ClassTemplateSpecializationDecl::getTemplateKeywordLoc
SourceLocation getTemplateKeywordLoc() const
Gets the location of the template keyword, if present.
Definition: DeclTemplate.h:2045
clang::ASTDeclWriter::VisitUnresolvedUsingIfExistsDecl
void VisitUnresolvedUsingIfExistsDecl(UnresolvedUsingIfExistsDecl *D)
Definition: ASTWriterDecl.cpp:1348
clang::FunctionDecl::hasInheritedPrototype
bool hasInheritedPrototype() const
Whether this function inherited its prototype from a previous declaration.
Definition: Decl.h:2272
clang::FunctionDecl::isExplicitlyDefaulted
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted.
Definition: Decl.h:2219
clang::UnresolvedUsingIfExistsDecl
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
Definition: DeclCXX.h:3892
clang::BlockDecl::canAvoidCopyToHeap
bool canAvoidCopyToHeap() const
Definition: Decl.h:4307
clang::LifetimeExtendedTemporaryDecl::getExtendingDecl
ValueDecl * getExtendingDecl()
Definition: DeclCXX.h:3131
clang::ASTDeclWriter::VisitOMPCapturedExprDecl
void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D)
Definition: ASTWriterDecl.cpp:1897
clang::TagDecl::getTagKind
TagKind getTagKind() const
Definition: Decl.h:3507
clang::ASTDeclWriter::VisitNonTypeTemplateParmDecl
void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D)
Definition: ASTWriterDecl.cpp:1697
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3180
clang::RedeclarableTemplateDecl::SpecEntryTraits::DeclType
EntryType DeclType
Definition: DeclTemplate.h:768
clang::Decl::getAttrs
AttrVec & getAttrs()
Definition: DeclBase.h:495
clang::VarTemplateSpecializationDecl::getSpecializedTemplate
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Definition: DeclTemplate.cpp:1321
clang::ASTDeclWriter::VisitTemplateDecl
void VisitTemplateDecl(TemplateDecl *D)
Definition: ASTWriterDecl.cpp:1495
clang::ExplicitSpecifier::getKind
ExplicitSpecKind getKind() const
Definition: DeclCXX.h:1803
clang::ObjCContainerDecl
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:945
clang::FunctionTemplateSpecializationInfo::TemplateArgumentsAsWritten
const ASTTemplateArgumentListInfo * TemplateArgumentsAsWritten
The template arguments as written in the sources, if provided.
Definition: DeclTemplate.h:488
clang::ObjCCategoryDecl::getCategoryNameLoc
SourceLocation getCategoryNameLoc() const
Definition: DeclObjC.h:2397
clang::TypeAliasTemplateDecl
Declaration of an alias template.
Definition: DeclTemplate.h:2516
clang::ASTDeclWriter::VisitObjCTypeParamDecl
void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D)
Definition: ASTWriterDecl.cpp:731
clang::FunctionDecl::getDependentSpecializationInfo
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3862
clang::BlockDecl::getSignatureAsWritten
TypeSourceInfo * getSignatureAsWritten() const
Definition: Decl.h:4236
clang::ASTDeclWriter::VisitTypedefDecl
void VisitTypedefDecl(TypedefDecl *D)
Definition: ASTWriterDecl.cpp:387
clang::ObjCMethodDecl::isPropertyAccessor
bool isPropertyAccessor() const
Definition: DeclObjC.h:441
clang::serialization::DECL_NAMESPACE_ALIAS
@ DECL_NAMESPACE_ALIAS
A NamespaceAliasDecl record.
Definition: ASTBitCodes.h:1340
clang::ConceptReference::getNestedNameSpecifierLoc
const NestedNameSpecifierLoc & getNestedNameSpecifierLoc() const
Definition: ASTConcept.h:138
clang::LifetimeExtendedTemporaryDecl
Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-...
Definition: DeclCXX.h:3094
clang::ObjCIvarDecl::classofKind
static bool classofKind(Kind K)
Definition: DeclObjC.h:1975
clang::BindingDecl::getBinding
Expr * getBinding() const
Get the expression to which this declaration is bound.
Definition: DeclCXX.h:3983
clang::ObjCMethodDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:376
clang::interp::DeclTy
unsigned llvm::PointerUnion< const Decl *, const Expr * > DeclTy
Definition: Descriptor.h:26
clang::FunctionTemplateSpecializationInfo::getTemplateSpecializationKind
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:529
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::ASTDeclWriter::Emit
uint64_t Emit(Decl *D)
Definition: ASTWriterDecl.cpp:48
clang::serialization::DECL_IMPORT
@ DECL_IMPORT
An ImportDecl recording a module import.
Definition: ASTBitCodes.h:1463
clang::ObjCMethodDecl::isRedeclaration
bool isRedeclaration() const
True if this is a method redeclaration in the same interface.
Definition: DeclObjC.h:269
clang::ConceptReference::getConceptNameInfo
const DeclarationNameInfo & getConceptNameInfo() const
Definition: ASTConcept.h:142
clang::ObjCPropertyDecl::getAtLoc
SourceLocation getAtLoc() const
Definition: DeclObjC.h:793
clang::ASTReader::getOwningModuleFile
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:7303
clang::ASTDeclWriter::VisitLinkageSpecDecl
void VisitLinkageSpecDecl(LinkageSpecDecl *D)
Definition: ASTWriterDecl.cpp:1214
clang::PragmaDetectMismatchDecl
Represents a #pragma detect_mismatch line.
Definition: Decl.h:174
clang::serialization::DECL_LABEL
@ DECL_LABEL
A LabelDecl record.
Definition: ASTBitCodes.h:1334
clang::UsingEnumDecl::getEnumLoc
SourceLocation getEnumLoc() const
The source location of the 'enum' keyword.
Definition: DeclCXX.h:3605
clang::DependentFunctionTemplateSpecializationInfo::getLAngleLoc
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:738
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::VarDecl::getInitStyle
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1376
clang::TypeAliasDecl
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3302
clang::NonTypeTemplateParmDecl::getPosition
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
Definition: DeclTemplate.h:1161
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:687
clang::MemberSpecializationInfo::getTemplateSpecializationKind
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:641
clang::ASTDeclWriter::VisitBindingDecl
void VisitBindingDecl(BindingDecl *D)
Definition: ASTWriterDecl.cpp:1145
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3075
clang::serialization::DECL_PRAGMA_DETECT_MISMATCH
@ DECL_PRAGMA_DETECT_MISMATCH
A PragmaDetectMismatchDecl record.
Definition: ASTBitCodes.h:1493
clang::ImportDecl::getImportedModule
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
Definition: Decl.h:4506
clang::RedeclarableTemplateDecl::isMemberSpecialization
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:885
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::IndirectFieldDecl::chain
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:3111
clang::PragmaDetectMismatchDecl::getValue
StringRef getValue() const
Definition: Decl.h:198
clang::FunctionDecl::getDescribedFunctionTemplate
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3689
SM
#define SM(sm)
Definition: Cuda.cpp:78
clang::ASTDeclWriter::VisitVarTemplateDecl
void VisitVarTemplateDecl(VarTemplateDecl *D)
Definition: ASTWriterDecl.cpp:1588
clang::ConstructorUsingShadowDecl
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3465
clang::ObjCInterfaceDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: DeclObjC.h:1895
clang::serialization::DeclID
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
clang::ASTContext::getInstantiatedFromUnnamedFieldDecl
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
Definition: ASTContext.cpp:1615
clang::BlockDecl::param_size
size_t param_size() const
Definition: Decl.h:4255
clang::serialization::UPD_CXX_ADDED_ANONYMOUS_NAMESPACE
@ UPD_CXX_ADDED_ANONYMOUS_NAMESPACE
Definition: ASTCommon.h:27
clang::TemplateParamObjectDecl::getValue
const APValue & getValue() const
Definition: DeclTemplate.h:3317
clang::UsingPackDecl::expansions
ArrayRef< NamedDecl * > expansions() const
Get the set of using declarations that this pack expanded into.
Definition: DeclCXX.h:3680
clang::FriendTemplateDecl::getNumTemplateParameters
unsigned getNumTemplateParameters() const
Definition: DeclTemplate.h:2501
clang::ObjCContainerDecl::getAtEndRange
SourceRange getAtEndRange() const
Definition: DeclObjC.h:1098
clang::ASTDeclWriter::AddFirstDeclFromEachModule
void AddFirstDeclFromEachModule(const Decl *D, bool IncludeLocal)
Add to the record the first declaration from each module file that provides a declaration of D.
Definition: ASTWriterDecl.cpp:179
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1799
clang::ObjCPropertyDecl::getPropertyAttributes
ObjCPropertyAttribute::Kind getPropertyAttributes() const
Definition: DeclObjC.h:812
clang::ASTDeclWriter
Definition: ASTWriterDecl.cpp:34
clang::serialization::DECL_CONTEXT_VISIBLE
@ DECL_CONTEXT_VISIBLE
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1331
clang::ASTContext::DeclMustBeEmitted
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
Definition: ASTContext.cpp:10987
clang::FunctionDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2483
clang::TemplateTemplateParmDecl::getDepth
unsigned getDepth() const
Get the nesting depth of the template parameter.
Definition: DeclTemplate.h:1157
clang::VarDecl::isExceptionVariable
bool isExceptionVariable() const
Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...
Definition: Decl.h:1404
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:430
clang::serialization::DECL_OBJC_IVAR
@ DECL_OBJC_IVAR
A ObjCIvarDecl record.
Definition: ASTBitCodes.h:1255
clang::FriendDecl::getFriendTypeTemplateParameterList
TemplateParameterList * getFriendTypeTemplateParameterList(unsigned N) const
Definition: DeclFriend.h:131
addExplicitSpecifier
static void addExplicitSpecifier(ExplicitSpecifier ES, ASTRecordWriter &Record)
Definition: ASTWriterDecl.cpp:665
clang::Decl::isCanonicalDecl
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:907
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:542
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1856
clang::ASTDeclWriter::VisitObjCContainerDecl
void VisitObjCContainerDecl(ObjCContainerDecl *D)
Definition: ASTWriterDecl.cpp:741
clang::ASTTemplateArgumentListInfo::RAngleLoc
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
Definition: TemplateBase.h:627
clang::BlockDecl::capturesCXXThis
bool capturesCXXThis() const
Definition: Decl.h:4285
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3859
clang::ASTContext::getInstantiatedFromUsingShadowDecl
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
Definition: ASTContext.cpp:1599
clang::ObjCList
ObjCList - This is a simple template class used to hold various lists of decls etc,...
Definition: DeclObjC.h:83
clang::ASTDeclWriter::VisitUsingDecl
void VisitUsingDecl(UsingDecl *D)
Definition: ASTWriterDecl.cpp:1271
clang::ObjCProtocolDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
Definition: DeclObjC.h:2205
clang::FunctionDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2580
clang::serialization::DECL_NON_TYPE_TEMPLATE_PARM
@ DECL_NON_TYPE_TEMPLATE_PARM
A NonTypeTemplateParmDecl record.
Definition: ASTBitCodes.h:1424
clang::NamespaceDecl::isInline
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:603
clang::TypeConstraint
Definition: ASTConcept.h:169
clang::VarTemplateSpecializationDecl::getSpecializationKind
TemplateSpecializationKind getSpecializationKind() const
Determine the kind of specialization that this declaration represents.
Definition: DeclTemplate.h:2762
clang::ASTDeclWriter::VisitUsingShadowDecl
void VisitUsingShadowDecl(UsingShadowDecl *D)
Definition: ASTWriterDecl.cpp:1301
clang::serialization::DECL_BINDING
@ DECL_BINDING
A BindingDecl record.
Definition: ASTBitCodes.h:1303
clang::ObjCCategoryDecl::protocol_size
unsigned protocol_size() const
Definition: DeclObjC.h:2349
clang::UsingDirectiveDecl::getNominatedNamespace
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2841
clang::DeclaratorDecl::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:757
clang::ParmVarDecl::hasInheritedDefaultArg
bool hasInheritedDefaultArg() const
Definition: Decl.h:1798
clang::ObjCMethodDecl::isVariadic
bool isVariadic() const
Definition: DeclObjC.h:436
clang::NamespaceDecl::getAnonymousNamespace
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:637
clang::ASTDeclWriter::VisitCXXConstructorDecl
void VisitCXXConstructorDecl(CXXConstructorDecl *D)
Definition: ASTWriterDecl.cpp:1410
clang::BlockDecl::isConversionFromLambda
bool isConversionFromLambda() const
Definition: Decl.h:4296
clang::OMPDeclarativeDirective::Data
OMPChildren * Data
Data, associated with the directive.
Definition: DeclOpenMP.h:43
clang::VarTemplateSpecializationDecl::getTypeAsWritten
TypeSourceInfo * getTypeAsWritten() const
Gets the type of this specialization as it was written by the user, if it was so written.
Definition: DeclTemplate.h:2873
clang::serialization::DECL_CONTEXT_LEXICAL
@ DECL_CONTEXT_LEXICAL
A record that stores the set of declarations that are lexically stored within a given DeclContext.
Definition: ASTBitCodes.h:1322
clang::FriendDecl::getFriendType
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:123
clang::UsingEnumDecl::getEnumDecl
EnumDecl * getEnumDecl() const
Definition: DeclCXX.h:3609
clang::ObjCMethodDecl::param_size
unsigned param_size() const
Definition: DeclObjC.h:350
clang::Decl::getMostRecentDecl
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:999
clang::Decl::getDeclKindName
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
clang::FunctionTemplateSpecializationInfo::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
Get the specialization info if this function template specialization is also a member specialization:
Definition: DeclTemplate.h:597
clang::TemplateTemplateParmDecl::isParameterPack
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
Definition: DeclTemplate.h:1666
clang::BlockDecl::blockMissingReturnType
bool blockMissingReturnType() const
Definition: Decl.h:4288
clang::BlockDecl::getNumCaptures
unsigned getNumCaptures() const
Returns the number of captured variables.
Definition: Decl.h:4276
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1948
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:439
clang::ObjCMethodDecl::getImplementationControl
ImplementationControl getImplementationControl() const
Definition: DeclObjC.h:502
clang::CXXDestructorDecl::getOperatorDeleteThisArg
Expr * getOperatorDeleteThisArg() const
Definition: DeclCXX.h:2705
clang::FunctionDecl::TK_DependentFunctionTemplateSpecialization
@ TK_DependentFunctionTemplateSpecialization
Definition: Decl.h:1877