clang 10.0.0git

ASTNodeTraverser.h
Go to the documentation of this file.
1 //===--- ASTNodeTraverser.h - Traversal of AST nodes ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the AST traversal facilities. Other users
10 // of this class may make use of the same traversal logic by inheriting it,
11 // similar to RecursiveASTVisitor.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_AST_ASTNODETRAVERSER_H
16 #define LLVM_CLANG_AST_ASTNODETRAVERSER_H
17
18 #include "clang/AST/AttrVisitor.h"
19 #include "clang/AST/CommentVisitor.h"
20 #include "clang/AST/DeclVisitor.h"
21 #include "clang/AST/LocInfoType.h"
22 #include "clang/AST/StmtVisitor.h"
23 #include "clang/AST/TemplateArgumentVisitor.h"
24 #include "clang/AST/TypeVisitor.h"
25
26 namespace clang {
27
28 /**
29
30 ASTNodeTraverser traverses the Clang AST for dumping purposes.
31
32 The `Derived::doGetNodeDelegate()` method is required to be an accessible member
33 which returns a reference of type `NodeDelegateType &` which implements the
34 following interface:
35
36 struct {
37 template <typename Fn> void AddChild(Fn DoAddChild);
38 template <typename Fn> void AddChild(StringRef Label, Fn DoAddChild);
39
40 void Visit(const comments::Comment *C, const comments::FullComment *FC);
41 void Visit(const Attr *A);
42 void Visit(const TemplateArgument &TA, SourceRange R = {},
43 const Decl *From = nullptr, StringRef Label = {});
44 void Visit(const Stmt *Node);
45 void Visit(const Type *T);
46 void Visit(QualType T);
47 void Visit(const Decl *D);
48 void Visit(const CXXCtorInitializer *Init);
49 void Visit(const OMPClause *C);
50 void Visit(const BlockDecl::Capture &C);
51 void Visit(const GenericSelectionExpr::ConstAssociation &A);
52 };
53 */
54 template <typename Derived, typename NodeDelegateType>
55 class ASTNodeTraverser
56 : public ConstDeclVisitor<Derived>,
57 public ConstStmtVisitor<Derived>,
58 public comments::ConstCommentVisitor<Derived, void,
59 const comments::FullComment *>,
60 public TypeVisitor<Derived>,
61 public ConstAttrVisitor<Derived>,
62 public ConstTemplateArgumentVisitor<Derived> {
63
64 /// Indicates whether we should trigger deserialization of nodes that had
65 /// not already been loaded.
66 bool Deserialize = false;
67
68 ast_type_traits::TraversalKind Traversal =
69 ast_type_traits::TraversalKind::TK_AsIs;
70
71 NodeDelegateType &getNodeDelegate() {
72 return getDerived().doGetNodeDelegate();
73 }
74 Derived &getDerived() { return *static_cast<Derived *>(this); }
75
76 public:
77 void setDeserialize(bool D) { Deserialize = D; }
78 bool getDeserialize() const { return Deserialize; }
79
80 void SetTraversalKind(ast_type_traits::TraversalKind TK) { Traversal = TK; }
81
82 void Visit(const Decl *D) {
83 getNodeDelegate().AddChild([=] {
84 getNodeDelegate().Visit(D);
85 if (!D)
86 return;
87
88 ConstDeclVisitor<Derived>::Visit(D);
89
90 for (const auto &A : D->attrs())
91 Visit(A);
92
93 if (const comments::FullComment *Comment =
94 D->getASTContext().getLocalCommentForDeclUncached(D))
95 Visit(Comment, Comment);
96
97 // Decls within functions are visited by the body.
98 if (!isa<FunctionDecl>(*D) && !isa<ObjCMethodDecl>(*D)) {
99 if (const auto *DC = dyn_cast<DeclContext>(D))
100 dumpDeclContext(DC);
101 }
102 });
103 }
104
105 void Visit(const Stmt *Node, StringRef Label = {}) {
106 getNodeDelegate().AddChild(Label, [=] {
107 const Stmt *S = Node;
108
109 if (auto *E = dyn_cast_or_null<Expr>(S)) {
110 switch (Traversal) {
111 case ast_type_traits::TK_AsIs:
112 break;
113 case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses:
114 S = E->IgnoreParenImpCasts();
115 break;
116 case ast_type_traits::TK_IgnoreUnlessSpelledInSource:
117 S = E->IgnoreUnlessSpelledInSource();
118 break;
119 }
120 }
121
122 getNodeDelegate().Visit(S);
123
124 if (!S) {
125 return;
126 }
127
128 ConstStmtVisitor<Derived>::Visit(S);
129
130 // Some statements have custom mechanisms for dumping their children.
131 if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S))
132 return;
133
134 if (isa<LambdaExpr>(S) &&
135 Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource)
136 return;
137
138 for (const Stmt *SubStmt : S->children())
139 Visit(SubStmt);
140 });
141 }
142
143 void Visit(QualType T) {
144 SplitQualType SQT = T.split();
145 if (!SQT.Quals.hasQualifiers())
146 return Visit(SQT.Ty);
147
148 getNodeDelegate().AddChild([=] {
149 getNodeDelegate().Visit(T);
150 Visit(T.split().Ty);
151 });
152 }
153
154 void Visit(const Type *T) {
155 getNodeDelegate().AddChild([=] {
156 getNodeDelegate().Visit(T);
157 if (!T)
158 return;
159 TypeVisitor<Derived>::Visit(T);
160
161 QualType SingleStepDesugar =
162 T->getLocallyUnqualifiedSingleStepDesugaredType();
163 if (SingleStepDesugar != QualType(T, 0))
164 Visit(SingleStepDesugar);
165 });
166 }
167
168 void Visit(const Attr *A) {
169 getNodeDelegate().AddChild([=] {
170 getNodeDelegate().Visit(A);
171 ConstAttrVisitor<Derived>::Visit(A);
172 });
173 }
174
175 void Visit(const CXXCtorInitializer *Init) {
176 getNodeDelegate().AddChild([=] {
177 getNodeDelegate().Visit(Init);
178 Visit(Init->getInit());
179 });
180 }
181
182 void Visit(const TemplateArgument &A, SourceRange R = {},
183 const Decl *From = nullptr, const char *Label = nullptr) {
184 getNodeDelegate().AddChild([=] {
185 getNodeDelegate().Visit(A, R, From, Label);
186 ConstTemplateArgumentVisitor<Derived>::Visit(A);
187 });
188 }
189
190 void Visit(const BlockDecl::Capture &C) {
191 getNodeDelegate().AddChild([=] {
192 getNodeDelegate().Visit(C);
193 if (C.hasCopyExpr())
194 Visit(C.getCopyExpr());
195 });
196 }
197
198 void Visit(const OMPClause *C) {
199 getNodeDelegate().AddChild([=] {
200 getNodeDelegate().Visit(C);
201 for (const auto *S : C->children())
202 Visit(S);
203 });
204 }
205
206 void Visit(const GenericSelectionExpr::ConstAssociation &A) {
207 getNodeDelegate().AddChild([=] {
208 getNodeDelegate().Visit(A);
209 if (const TypeSourceInfo *TSI = A.getTypeSourceInfo())
210 Visit(TSI->getType());
211 Visit(A.getAssociationExpr());
212 });
213 }
214
215 void Visit(const comments::Comment *C, const comments::FullComment *FC) {
216 getNodeDelegate().AddChild([=] {
217 getNodeDelegate().Visit(C, FC);
218 if (!C) {
219 return;
220 }
221 comments::ConstCommentVisitor<Derived, void,
222 const comments::FullComment *>::visit(C,
223 FC);
224 for (comments::Comment::child_iterator I = C->child_begin(),
225 E = C->child_end();
226 I != E; ++I)
227 Visit(*I, FC);
228 });
229 }
230
231 void Visit(const ast_type_traits::DynTypedNode &N) {
232 // FIXME: Improve this with a switch or a visitor pattern.
233 if (const auto *D = N.get<Decl>())
234 Visit(D);
235 else if (const auto *S = N.get<Stmt>())
236 Visit(S);
237 else if (const auto *QT = N.get<QualType>())
238 Visit(*QT);
239 else if (const auto *T = N.get<Type>())
240 Visit(T);
241 else if (const auto *C = N.get<CXXCtorInitializer>())
242 Visit(C);
243 else if (const auto *C = N.get<OMPClause>())
244 Visit(C);
245 else if (const auto *T = N.get<TemplateArgument>())
246 Visit(*T);
247 }
248
249 void dumpDeclContext(const DeclContext *DC) {
250 if (!DC)
251 return;
252
253 for (const auto *D : (Deserialize ? DC->decls() : DC->noload_decls()))
254 Visit(D);
255 }
256
257 void dumpTemplateParameters(const TemplateParameterList *TPL) {
258 if (!TPL)
259 return;
260
261 for (const auto &TP : *TPL)
262 Visit(TP);
263
264 if (const Expr *RC = TPL->getRequiresClause())
265 Visit(RC);
266 }
267
268 void
269 dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI) {
270 if (!TALI)
271 return;
272
273 for (const auto &TA : TALI->arguments())
274 dumpTemplateArgumentLoc(TA);
275 }
276
277 void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A,
278 const Decl *From = nullptr,
279 const char *Label = nullptr) {
280 Visit(A.getArgument(), A.getSourceRange(), From, Label);
281 }
282
283 void dumpTemplateArgumentList(const TemplateArgumentList &TAL) {
284 for (unsigned i = 0, e = TAL.size(); i < e; ++i)
285 Visit(TAL[i]);
286 }
287
288 void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams) {
289 if (!typeParams)
290 return;
291
292 for (const auto &typeParam : *typeParams) {
293 Visit(typeParam);
294 }
295 }
296
297 void VisitComplexType(const ComplexType *T) { Visit(T->getElementType()); }
298 void VisitLocInfoType(const LocInfoType *T) {
299 Visit(T->getTypeSourceInfo()->getType());
300 }
301 void VisitPointerType(const PointerType *T) { Visit(T->getPointeeType()); }
302 void VisitBlockPointerType(const BlockPointerType *T) {
303 Visit(T->getPointeeType());
304 }
305 void VisitReferenceType(const ReferenceType *T) {
306 Visit(T->getPointeeType());
307 }
308 void VisitMemberPointerType(const MemberPointerType *T) {
309 Visit(T->getClass());
310 Visit(T->getPointeeType());
311 }
312 void VisitArrayType(const ArrayType *T) { Visit(T->getElementType()); }
313 void VisitVariableArrayType(const VariableArrayType *T) {
314 VisitArrayType(T);
315 Visit(T->getSizeExpr());
316 }
317 void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
318 Visit(T->getElementType());
319 Visit(T->getSizeExpr());
320 }
321 void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
322 Visit(T->getElementType());
323 Visit(T->getSizeExpr());
324 }
325 void VisitVectorType(const VectorType *T) { Visit(T->getElementType()); }
326 void VisitFunctionType(const FunctionType *T) { Visit(T->getReturnType()); }
327 void VisitFunctionProtoType(const FunctionProtoType *T) {
328 VisitFunctionType(T);
329 for (const QualType &PT : T->getParamTypes())
330 Visit(PT);
331 }
332 void VisitTypeOfExprType(const TypeOfExprType *T) {
333 Visit(T->getUnderlyingExpr());
334 }
335 void VisitDecltypeType(const DecltypeType *T) {
336 Visit(T->getUnderlyingExpr());
337 }
338 void VisitUnaryTransformType(const UnaryTransformType *T) {
339 Visit(T->getBaseType());
340 }
341 void VisitAttributedType(const AttributedType *T) {
342 // FIXME: AttrKind
343 Visit(T->getModifiedType());
344 }
345 void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
346 Visit(T->getReplacedParameter());
347 }
348 void
349 VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
350 Visit(T->getReplacedParameter());
351 Visit(T->getArgumentPack());
352 }
353 void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
354 for (const auto &Arg : *T)
355 Visit(Arg);
356 if (T->isTypeAlias())
357 Visit(T->getAliasedType());
358 }
359 void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
360 Visit(T->getPointeeType());
361 }
362 void VisitAtomicType(const AtomicType *T) { Visit(T->getValueType()); }
363 void VisitPipeType(const PipeType *T) { Visit(T->getElementType()); }
364 void VisitAdjustedType(const AdjustedType *T) { Visit(T->getOriginalType()); }
365 void VisitPackExpansionType(const PackExpansionType *T) {
366 if (!T->isSugared())
367 Visit(T->getPattern());
368 }
369 // FIXME: ElaboratedType, DependentNameType,
370 // DependentTemplateSpecializationType, ObjCObjectType
371
372 void VisitTypedefDecl(const TypedefDecl *D) { Visit(D->getUnderlyingType()); }
373
374 void VisitEnumConstantDecl(const EnumConstantDecl *D) {
375 if (const Expr *Init = D->getInitExpr())
376 Visit(Init);
377 }
378
379 void VisitFunctionDecl(const FunctionDecl *D) {
380 if (const auto *FTSI = D->getTemplateSpecializationInfo())
381 dumpTemplateArgumentList(*FTSI->TemplateArguments);
382
383 if (D->param_begin())
384 for (const auto *Parameter : D->parameters())
385 Visit(Parameter);
386
387 if (const Expr *TRC = D->getTrailingRequiresClause())
388 Visit(TRC);
389
390 if (const auto *C = dyn_cast<CXXConstructorDecl>(D))
391 for (const auto *I : C->inits())
392 Visit(I);
393
394 if (D->doesThisDeclarationHaveABody())
395 Visit(D->getBody());
396 }
397
398 void VisitFieldDecl(const FieldDecl *D) {
399 if (D->isBitField())
400 Visit(D->getBitWidth());
401 if (Expr *Init = D->getInClassInitializer())
402 Visit(Init);
403 }
404
405 void VisitVarDecl(const VarDecl *D) {
406 if (D->hasInit())
407 Visit(D->getInit());
408 }
409
410 void VisitDecompositionDecl(const DecompositionDecl *D) {
411 VisitVarDecl(D);
412 for (const auto *B : D->bindings())
413 Visit(B);
414 }
415
416 void VisitBindingDecl(const BindingDecl *D) {
417 if (const auto *E = D->getBinding())
418 Visit(E);
419 }
420
421 void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D) {
422 Visit(D->getAsmString());
423 }
424
425 void VisitCapturedDecl(const CapturedDecl *D) { Visit(D->getBody()); }
426
427 void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D) {
428 for (const auto *E : D->varlists())
429 Visit(E);
430 }
431
432 void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D) {
433 Visit(D->getCombiner());
434 if (const auto *Initializer = D->getInitializer())
435 Visit(Initializer);
436 }
437
438 void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D) {
439 for (const auto *C : D->clauselists())
440 Visit(C);
441 }
442
443 void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
444 Visit(D->getInit());
445 }
446
447 void VisitOMPAllocateDecl(const OMPAllocateDecl *D) {
448 for (const auto *E : D->varlists())
449 Visit(E);
450 for (const auto *C : D->clauselists())
451 Visit(C);
452 }
453
454 template <typename SpecializationDecl>
455 void dumpTemplateDeclSpecialization(const SpecializationDecl *D) {
456 for (const auto *RedeclWithBadType : D->redecls()) {
457 // FIXME: The redecls() range sometimes has elements of a less-specific
458 // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
459 // us TagDecls, and should give CXXRecordDecls).
460 auto *Redecl = dyn_cast<SpecializationDecl>(RedeclWithBadType);
461 if (!Redecl) {
462 // Found the injected-class-name for a class template. This will be
463 // dumped as part of its surrounding class so we don't need to dump it
464 // here.
465 assert(isa<CXXRecordDecl>(RedeclWithBadType) &&
466 "expected an injected-class-name");
467 continue;
468 }
469 Visit(Redecl);
470 }
471 }
472
473 template <typename TemplateDecl>
474 void dumpTemplateDecl(const TemplateDecl *D) {
475 dumpTemplateParameters(D->getTemplateParameters());
476
477 Visit(D->getTemplatedDecl());
478
479 for (const auto *Child : D->specializations())
480 dumpTemplateDeclSpecialization(Child);
481 }
482
483 void VisitTypeAliasDecl(const TypeAliasDecl *D) {
484 Visit(D->getUnderlyingType());
485 }
486
487 void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
488 dumpTemplateParameters(D->getTemplateParameters());
489 Visit(D->getTemplatedDecl());
490 }
491
492 void VisitStaticAssertDecl(const StaticAssertDecl *D) {
493 Visit(D->getAssertExpr());
494 Visit(D->getMessage());
495 }
496
497 void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
498 dumpTemplateDecl(D);
499 }
500
501 void VisitClassTemplateDecl(const ClassTemplateDecl *D) {
502 dumpTemplateDecl(D);
503 }
504
505 void VisitClassTemplateSpecializationDecl(
506 const ClassTemplateSpecializationDecl *D) {
507 dumpTemplateArgumentList(D->getTemplateArgs());
508 }
509
510 void VisitClassTemplatePartialSpecializationDecl(
511 const ClassTemplatePartialSpecializationDecl *D) {
512 VisitClassTemplateSpecializationDecl(D);
513 dumpTemplateParameters(D->getTemplateParameters());
514 }
515
516 void VisitClassScopeFunctionSpecializationDecl(
517 const ClassScopeFunctionSpecializationDecl *D) {
518 Visit(D->getSpecialization());
519 dumpASTTemplateArgumentListInfo(D->getTemplateArgsAsWritten());
520 }
521 void VisitVarTemplateDecl(const VarTemplateDecl *D) { dumpTemplateDecl(D); }
522
523 void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
524 dumpTemplateParameters(D->getTemplateParameters());
525 }
526
527 void
528 VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D) {
529 dumpTemplateArgumentList(D->getTemplateArgs());
530 VisitVarDecl(D);
531 }
532
533 void VisitVarTemplatePartialSpecializationDecl(
534 const VarTemplatePartialSpecializationDecl *D) {
535 dumpTemplateParameters(D->getTemplateParameters());
536 VisitVarTemplateSpecializationDecl(D);
537 }
538
539 void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
540 if (const auto *TC = D->getTypeConstraint())
541 if (TC->hasExplicitTemplateArgs())
542 for (const auto &ArgLoc : TC->getTemplateArgsAsWritten()->arguments())
543 dumpTemplateArgumentLoc(ArgLoc);
544 if (D->hasDefaultArgument())
545 Visit(D->getDefaultArgument(), SourceRange(),
546 D->getDefaultArgStorage().getInheritedFrom(),
547 D->defaultArgumentWasInherited() ? "inherited from" : "previous");
548 }
549
550 void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
551 if (const auto *E = D->getPlaceholderTypeConstraint())
552 Visit(E);
553 if (D->hasDefaultArgument())
554 Visit(D->getDefaultArgument(), SourceRange(),
555 D->getDefaultArgStorage().getInheritedFrom(),
556 D->defaultArgumentWasInherited() ? "inherited from" : "previous");
557 }
558
559 void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
560 dumpTemplateParameters(D->getTemplateParameters());
561 if (D->hasDefaultArgument())
562 dumpTemplateArgumentLoc(
563 D->getDefaultArgument(), D->getDefaultArgStorage().getInheritedFrom(),
564 D->defaultArgumentWasInherited() ? "inherited from" : "previous");
565 }
566
567 void VisitConceptDecl(const ConceptDecl *D) {
568 dumpTemplateParameters(D->getTemplateParameters());
569 Visit(D->getConstraintExpr());
570 }
571
572 void VisitUsingShadowDecl(const UsingShadowDecl *D) {
573 if (auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))
574 Visit(TD->getTypeForDecl());
575 }
576
577 void VisitFriendDecl(const FriendDecl *D) {
578 if (!D->getFriendType())
579 Visit(D->getFriendDecl());
580 }
581
582 void VisitObjCMethodDecl(const ObjCMethodDecl *D) {
583 if (D->isThisDeclarationADefinition())
584 dumpDeclContext(D);
585 else
586 for (const ParmVarDecl *Parameter : D->parameters())
587 Visit(Parameter);
588
589 if (D->hasBody())
590 Visit(D->getBody());
591 }
592
593 void VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
594 dumpObjCTypeParamList(D->getTypeParamList());
595 }
596
597 void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
598 dumpObjCTypeParamList(D->getTypeParamListAsWritten());
599 }
600
601 void VisitObjCImplementationDecl(const ObjCImplementationDecl *D) {
602 for (const auto &I : D->inits())
603 Visit(I);
604 }
605
606 void VisitBlockDecl(const BlockDecl *D) {
607 for (const auto &I : D->parameters())
608 Visit(I);
609
610 for (const auto &I : D->captures())
611 Visit(I);
612 Visit(D->getBody());
613 }
614
615 void VisitDeclStmt(const DeclStmt *Node) {
616 for (const auto &D : Node->decls())
617 Visit(D);
618 }
619
620 void VisitAttributedStmt(const AttributedStmt *Node) {
621 for (const auto *A : Node->getAttrs())
622 Visit(A);
623 }
624
625 void VisitCXXCatchStmt(const CXXCatchStmt *Node) {
626 Visit(Node->getExceptionDecl());
627 }
628
629 void VisitCapturedStmt(const CapturedStmt *Node) {
630 Visit(Node->getCapturedDecl());
631 }
632
633 void VisitOMPExecutableDirective(const OMPExecutableDirective *Node) {
634 for (const auto *C : Node->clauses())
635 Visit(C);
636 }
637
638 void VisitInitListExpr(const InitListExpr *ILE) {
639 if (auto *Filler = ILE->getArrayFiller()) {
640 Visit(Filler, "array_filler");
641 }
642 }
643
644 void VisitBlockExpr(const BlockExpr *Node) { Visit(Node->getBlockDecl()); }
645
646 void VisitOpaqueValueExpr(const OpaqueValueExpr *Node) {
647 if (Expr *Source = Node->getSourceExpr())
648 Visit(Source);
649 }
650
651 void VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
652 Visit(E->getControllingExpr());
653 Visit(E->getControllingExpr()->getType()); // FIXME: remove
654
655 for (const auto Assoc : E->associations()) {
656 Visit(Assoc);
657 }
658 }
659
660 void VisitLambdaExpr(const LambdaExpr *Node) {
661 if (Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
662 for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
663 const auto *C = Node->capture_begin() + I;
664 if (!C->isExplicit())
665 continue;
666 if (Node->isInitCapture(C))
667 Visit(C->getCapturedVar());
668 else
669 Visit(Node->capture_init_begin()[I]);
670 }
671 dumpTemplateParameters(Node->getTemplateParameterList());
672 for (const auto *P : Node->getCallOperator()->parameters())
673 Visit(P);
674 Visit(Node->getBody());
675 } else {
676 return Visit(Node->getLambdaClass());
677 }
678 }
679
680 void VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
681 if (Node->isPartiallySubstituted())
682 for (const auto &A : Node->getPartialArguments())
683 Visit(A);
684 }
685
686 void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
687 if (const VarDecl *CatchParam = Node->getCatchParamDecl())
688 Visit(CatchParam);
689 }
690
691 void VisitExpressionTemplateArgument(const TemplateArgument &TA) {
692 Visit(TA.getAsExpr());
693 }
694 void VisitPackTemplateArgument(const TemplateArgument &TA) {
695 for (const auto &TArg : TA.pack_elements())
696 Visit(TArg);
697 }
698
699 // Implements Visit methods for Attrs.
700 #include "clang/AST/AttrNodeTraverse.inc"
701 };
702
703 } // namespace clang
704
705 #endif // LLVM_CLANG_AST_ASTNODETRAVERSER_H
clang::OMPDeclareMapperDecl::clauselists
clauselist_range clauselists()
Definition: DeclOpenMP.h:270
clang::ASTNodeTraverser::dumpTemplateDeclSpecialization
void dumpTemplateDeclSpecialization(const SpecializationDecl *D)
Definition: ASTNodeTraverser.h:455
clang::PackExpansionType::getPattern
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5532
clang::BlockExpr::getBlockDecl
const BlockDecl * getBlockDecl() const
Definition: Expr.h:5593
clang::BlockDecl::Capture::hasCopyExpr
bool hasCopyExpr() const
Definition: Decl.h:4082
clang::SplitQualType::Ty
const Type * Ty
The locally-unqualified type.
Definition: Type.h:595
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1783
clang::CXXCtorInitializer::getInit
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2353
clang::ObjCMethodDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Returns whether this specific method is a definition.
Definition: DeclObjC.h:527
clang::ASTNodeTraverser::VisitFunctionTemplateDecl
void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D)
Definition: ASTNodeTraverser.h:497
clang::DynamicInitKind::Initializer
clang::BlockDecl::Capture::getCopyExpr
Expr * getCopyExpr() const
Definition: Decl.h:4083
clang::ASTNodeTraverser::getDeserialize
bool getDeserialize() const
Definition: ASTNodeTraverser.h:78
clang::BlockDecl::Capture
A class which contains all the information about a particular captured value.
Definition: Decl.h:4043
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
clang::PipeType::getElementType
QualType getElementType() const
Definition: Type.h:6173
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2627
clang::ASTNodeTraverser::VisitNonTypeTemplateParmDecl
void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D)
Definition: ASTNodeTraverser.h:550
clang::ASTNodeTraverser::VisitAttributedStmt
void VisitAttributedStmt(const AttributedStmt *Node)
Definition: ASTNodeTraverser.h:620
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:654
clang::ASTNodeTraverser::dumpTemplateParameters
void dumpTemplateParameters(const TemplateParameterList *TPL)
Definition: ASTNodeTraverser.h:257
clang::OMPExecutableDirective::clauses
ArrayRef< OMPClause * > clauses()
Definition: StmtOpenMP.h:325
TypeVisitor.h
clang::ASTNodeTraverser::VisitBlockPointerType
void VisitBlockPointerType(const BlockPointerType *T)
Definition: ASTNodeTraverser.h:302
clang::ConstStmtVisitor
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:193
clang::ASTNodeTraverser::VisitAdjustedType
void VisitAdjustedType(const AdjustedType *T)
Definition: ASTNodeTraverser.h:364
clang::ASTNodeTraverser::VisitPackTemplateArgument
void VisitPackTemplateArgument(const TemplateArgument &TA)
Definition: ASTNodeTraverser.h:694
clang::ClassScopeFunctionSpecializationDecl::getTemplateArgsAsWritten
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: DeclTemplate.h:2616
clang::templateargumentvisitor::Base< llvm::make_const_ref, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(REF(TemplateArgument) TA, ParamTys... P)
Definition: TemplateArgumentVisitor.h:33
clang::ASTNodeTraverser::dumpTemplateArgumentList
void dumpTemplateArgumentList(const TemplateArgumentList &TAL)
Definition: ASTNodeTraverser.h:283
clang::GenericSelectionExpr::getControllingExpr
Expr * getControllingExpr()
Return the controlling expression of this generic selection expression.
Definition: Expr.h:5417
clang::DecltypeType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4380
clang::ASTNodeTraverser::VisitObjCAtCatchStmt
void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node)
Definition: ASTNodeTraverser.h:686
clang::ASTNodeTraverser::VisitOMPDeclareMapperDecl
void VisitOMPDeclareMapperDecl(const OMPDeclareMapperDecl *D)
Definition: ASTNodeTraverser.h:438
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
clang::FieldDecl::getBitWidth
Expr * getBitWidth() const
Definition: Decl.h:2818
clang::OMPAllocateDecl
This represents &#39;#pragma omp allocate ...&#39; directive.
Definition: DeclOpenMP.h:422
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2941
clang::ASTNodeTraverser::VisitAttributedType
void VisitAttributedType(const AttributedType *T)
Definition: ASTNodeTraverser.h:341
clang::TypedefDecl
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3173
clang::ASTNodeTraverser::Visit
void Visit(QualType T)
Definition: ASTNodeTraverser.h:143
clang::ASTNodeTraverser::VisitFunctionDecl
void VisitFunctionDecl(const FunctionDecl *D)
Definition: ASTNodeTraverser.h:379
clang::TemplateArgumentList::size
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:299
clang::ast_type_traits::DynTypedNode::get
const T * get() const
Retrieve the stored node as type T.
Definition: ASTTypeTraits.h:251
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::TemplateDecl::getTemplatedDecl
NamedDecl * getTemplatedDecl() const
Get the underlying, templated declaration.
Definition: DeclTemplate.h:434
clang::ASTNodeTraverser::VisitExpressionTemplateArgument
void VisitExpressionTemplateArgument(const TemplateArgument &TA)
Definition: ASTNodeTraverser.h:691
clang::AttributedStmt
Represents an attribute applied to a statement.
Definition: Stmt.h:1776
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1450
clang::NonTypeTemplateParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1458
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3070
clang::ArrayType
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
clang::TypeVisitor::Visit
RetTy Visit(const Type *T)
Performs the operation associated with this visitor object.
Definition: TypeVisitor.h:68
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6227
clang::AtomicType::getValueType
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6140
clang::VarTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2968
clang::comments::Comment::child_begin
child_iterator child_begin() const
Definition: Comment.cpp:82
clang::ASTNodeTraverser::Visit
void Visit(const comments::Comment *C, const comments::FullComment *FC)
Definition: ASTNodeTraverser.h:215
clang::ASTNodeTraverser::dumpASTTemplateArgumentListInfo
void dumpASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *TALI)
Definition: ASTNodeTraverser.h:269
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2910
clang::NonTypeTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1472
clang::ClassTemplatePartialSpecializationDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:2123
TemplateArgumentVisitor.h
clang::FriendDecl
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:53
clang::ASTNodeTraverser::VisitBlockExpr
void VisitBlockExpr(const BlockExpr *Node)
Definition: ASTNodeTraverser.h:644
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::ASTNodeTraverser::VisitFileScopeAsmDecl
void VisitFileScopeAsmDecl(const FileScopeAsmDecl *D)
Definition: ASTNodeTraverser.h:421
clang::NonTypeTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1462
clang::DeclContext::decls
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2033
clang::ASTNodeTraverser::VisitCXXCatchStmt
void VisitCXXCatchStmt(const CXXCatchStmt *Node)
Definition: ASTNodeTraverser.h:625
clang::VarTemplateSpecializationDecl
Represents a variable template specialization, which refers to a variable template with a given set o...
Definition: DeclTemplate.h:2655
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
clang::ASTNodeTraverser::VisitVarTemplatePartialSpecializationDecl
void VisitVarTemplatePartialSpecializationDecl(const VarTemplatePartialSpecializationDecl *D)
Definition: ASTNodeTraverser.h:533
clang::ASTTemplateArgumentListInfo
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::ASTNodeTraverser::Visit
void Visit(const Decl *D)
Definition: ASTNodeTraverser.h:82
clang::ASTTemplateArgumentListInfo::arguments
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:631
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1595
clang::SubstTemplateTypeParmType
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4728
clang::BuiltinTemplateDecl
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
Definition: DeclTemplate.h:1763
clang::LambdaExpr::getLambdaClass
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1283
clang::PipeType
PipeType - OpenCL20.
Definition: Type.h:6159
clang::ClassTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
Definition: DeclTemplate.h:1890
clang::ASTNodeTraverser::VisitObjCMethodDecl
void VisitObjCMethodDecl(const ObjCMethodDecl *D)
Definition: ASTNodeTraverser.h:582
clang::AdjustedType::getOriginalType
QualType getOriginalType() const
Definition: Type.h:2678
clang::ClassTemplateSpecializationDecl
Represents a class template specialization, which refers to a class template with a given set of temp...
Definition: DeclTemplate.h:1802
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::StaticAssertDecl::getMessage
StringLiteral * getMessage()
Definition: DeclCXX.h:3789
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2731
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:329
clang::ASTNodeTraverser::VisitVariableArrayType
void VisitVariableArrayType(const VariableArrayType *T)
Definition: ASTNodeTraverser.h:313
clang::FunctionProtoType::getParamTypes
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3971
clang::ast_type_traits::TK_AsIs
Will traverse all child nodes.
Definition: ASTTypeTraits.h:42
clang::ASTNodeTraverser::VisitGenericSelectionExpr
void VisitGenericSelectionExpr(const GenericSelectionExpr *E)
Definition: ASTNodeTraverser.h:651
clang::TemplateTemplateParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1714
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2729
clang::ConstAttrVisitor
A simple visitor class that helps create attribute visitors.
Definition: AttrVisitor.h:69
clang::ASTNodeTraverser::VisitSizeOfPackExpr
void VisitSizeOfPackExpr(const SizeOfPackExpr *Node)
Definition: ASTNodeTraverser.h:680
clang::TypeVisitor
An operation on a type.
Definition: TypeVisitor.h:64
clang::LambdaExpr::getBody
CompoundStmt * getBody() const
Retrieve the body of the lambda.
Definition: ExprCXX.cpp:1307
clang::FriendDecl::getFriendDecl
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:138
clang::ObjCInterfaceDecl::getTypeParamListAsWritten
ObjCTypeParamList * getTypeParamListAsWritten() const
Retrieve the type parameters written on this particular declaration of the class. ...
Definition: DeclObjC.h:1325
clang::SubstTemplateTypeParmPackType
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4784
clang::OpaqueValueExpr::getSourceExpr
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:1133
clang::ASTNodeTraverser::Visit
void Visit(const OMPClause *C)
Definition: ASTNodeTraverser.h:198
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:4116
clang::ASTNodeTraverser::VisitOMPAllocateDecl
void VisitOMPAllocateDecl(const OMPAllocateDecl *D)
Definition: ASTNodeTraverser.h:447
clang::ClassScopeFunctionSpecializationDecl
Declaration of a function specialization at template class scope.
Definition: DeclTemplate.h:2595
clang::TemplateArgumentLoc::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Definition: TemplateBase.cpp:469
clang::ASTNodeTraverser::VisitFunctionProtoType
void VisitFunctionProtoType(const FunctionProtoType *T)
Definition: ASTNodeTraverser.h:327
LocInfoType.h
clang::FunctionDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2399
clang::ObjCAtCatchStmt
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
clang::TypeAliasTemplateDecl::getTemplatedDecl
TypeAliasDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Definition: DeclTemplate.h:2532
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4403
clang::CapturedDecl::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.cpp:4748
clang::DecompositionDecl::bindings
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:3903
clang::OMPDeclareReductionDecl::getInitializer
Expr * getInitializer()
Get initializer expression (if specified) of the declare reduction construct.
Definition: DeclOpenMP.h:170
clang::GenericSelectionExpr::ConstAssociation
AssociationTy< true > ConstAssociation
Definition: Expr.h:5394
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2807
clang::ASTNodeTraverser::VisitTypeOfExprType
void VisitTypeOfExprType(const TypeOfExprType *T)
Definition: ASTNodeTraverser.h:332
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2894
clang::ASTNodeTraverser::VisitPackExpansionType
void VisitPackExpansionType(const PackExpansionType *T)
Definition: ASTNodeTraverser.h:365
clang::VarTemplateSpecializationDecl::getTemplateArgs
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
Definition: DeclTemplate.h:2746
clang::TemplateTypeParmDecl::getTypeConstraint
const TypeConstraint * getTypeConstraint() const
Returns the type constraint associated with this template parameter (if any).
Definition: DeclTemplate.h:1345
clang::ASTNodeTraverser::VisitTemplateSpecializationType
void VisitTemplateSpecializationType(const TemplateSpecializationType *T)
Definition: ASTNodeTraverser.h:353
clang::LambdaExpr::capture_init_begin
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1963
clang::ConstTemplateArgumentVisitor
A simple visitor class that helps create template argument visitors.
Definition: TemplateArgumentVisitor.h:92
clang::Stmt::children
child_range children()
Definition: Stmt.cpp:224
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4300
clang::ASTNodeTraverser::VisitUsingShadowDecl
void VisitUsingShadowDecl(const UsingShadowDecl *D)
Definition: ASTNodeTraverser.h:572
clang::MemberPointerType::getClass
const Type * getClass() const
Definition: Type.h:2867
clang::comments::Comment
Any part of the comment.
Definition: Comment.h:52
clang::ASTNodeTraverser::VisitOMPExecutableDirective
void VisitOMPExecutableDirective(const OMPExecutableDirective *Node)
Definition: ASTNodeTraverser.h:633
clang::FunctionDecl::getTemplateSpecializationInfo
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3663
clang::VariableArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3058
clang::ASTNodeTraverser::Visit
void Visit(const Type *T)
Definition: ASTNodeTraverser.h:154
clang::ASTNodeTraverser::VisitCapturedDecl
void VisitCapturedDecl(const CapturedDecl *D)
Definition: ASTNodeTraverser.h:425
clang::EnumConstantDecl::getInitExpr
const Expr * getInitExpr() const
Definition: Decl.h:2960
clang::ASTNodeTraverser::VisitTemplateTemplateParmDecl
void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D)
Definition: ASTNodeTraverser.h:559
clang::TemplateTypeParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1248
clang::ASTNodeTraverser::VisitBlockDecl
void VisitBlockDecl(const BlockDecl *D)
Definition: ASTNodeTraverser.h:606
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1818
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4226
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
clang::LambdaExpr::isInitCapture
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda&#39;s captures is an init-capture.
Definition: ExprCXX.cpp:1240
clang::ASTNodeTraverser::VisitCapturedStmt
void VisitCapturedStmt(const CapturedStmt *Node)
Definition: ASTNodeTraverser.h:629
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3812
clang::DependentSizedArrayType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3115
clang::ASTNodeTraverser::dumpObjCTypeParamList
void dumpObjCTypeParamList(const ObjCTypeParamList *typeParams)
Definition: ASTNodeTraverser.h:288
clang::ASTNodeTraverser::dumpTemplateArgumentLoc
void dumpTemplateArgumentLoc(const TemplateArgumentLoc &A, const Decl *From=nullptr, const char *Label=nullptr)
Definition: ASTNodeTraverser.h:277
clang::DependentSizedExtVectorType::getElementType
QualType getElementType() const
Definition: Type.h:3211
clang::DependentSizedExtVectorType
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3195
clang::FunctionDecl::param_begin
param_iterator param_begin()
Definition: Decl.h:2411
clang::ASTNodeTraverser::VisitInitListExpr
void VisitInitListExpr(const InitListExpr *ILE)
Definition: ASTNodeTraverser.h:638
clang::OMPClause::children
child_range children()
Definition: OpenMPClause.cpp:27
clang::ASTNodeTraverser::Visit
void Visit(const Stmt *Node, StringRef Label={})
Definition: ASTNodeTraverser.h:105
clang::TypeAliasDecl
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3193
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
clang::ASTNodeTraverser::Visit
void Visit(const GenericSelectionExpr::ConstAssociation &A)
Definition: ASTNodeTraverser.h:206
clang::LocInfoType
Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing.
Definition: LocInfoType.h:28
clang::comments::Comment::child_end
child_iterator child_end() const
Definition: Comment.cpp:96
clang::ASTNodeTraverser::VisitFriendDecl
void VisitFriendDecl(const FriendDecl *D)
Definition: ASTNodeTraverser.h:577
clang::DeclContext::noload_decls
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:2041
clang::ASTNodeTraverser::VisitTypeAliasTemplateDecl
void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D)
Definition: ASTNodeTraverser.h:487
clang::ASTNodeTraverser::VisitObjCInterfaceDecl
void VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D)
Definition: ASTNodeTraverser.h:597
clang::OMPDeclareReductionDecl::getCombiner
Expr * getCombiner()
Get combiner expression of the declare reduction construct.
Definition: DeclOpenMP.h:152
clang::ASTNodeTraverser::VisitObjCObjectPointerType
void VisitObjCObjectPointerType(const ObjCObjectPointerType *T)
Definition: ASTNodeTraverser.h:359
clang::ASTNodeTraverser::VisitFieldDecl
void VisitFieldDecl(const FieldDecl *D)
Definition: ASTNodeTraverser.h:398
clang::DependentSizedArrayType
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3093
clang::TemplateDecl::getTemplateParameters
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:421
clang::ComplexType::getElementType
QualType getElementType() const
Definition: Type.h:2567
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4037
clang::Expr
This represents one expression.
Definition: Expr.h:108
clang::ReferenceType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2771
Label
std::string Label
Definition: UsingDeclarationsSorter.cpp:69
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:1561
clang::TemplateTypeParmDecl
Declaration of a template type parameter.
Definition: DeclTemplate.h:1177
clang::ast_type_traits::TK_IgnoreImplicitCastsAndParentheses
Will not traverse implicit casts and parentheses.
Definition: ASTTypeTraits.h:46
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5579
clang::ASTNodeTraverser::dumpTemplateDecl
void dumpTemplateDecl(const TemplateDecl *D)
Definition: ASTNodeTraverser.h:474
clang::CXXCatchStmt::getExceptionDecl
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:49
clang::ast_type_traits::TK_IgnoreUnlessSpelledInSource
Ignore AST nodes not written in the source.
Definition: ASTTypeTraits.h:49
clang::UnaryTransformType::getBaseType
QualType getBaseType() const
Definition: Type.h:4439
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4091
clang::ASTNodeTraverser::Visit
void Visit(const CXXCtorInitializer *Init)
Definition: ASTNodeTraverser.h:175
clang::NonTypeTemplateParmDecl
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Definition: DeclTemplate.h:1383
DeclVisitor.h
clang::DecltypeType
Represents the type decltype(expr) (C++11).
Definition: Type.h:4370
clang::SplitQualType
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:593
clang::Expr::getType
QualType getType() const
Definition: Expr.h:137
clang::UnaryTransformType
A unary type transform, which is a type constructed from another.
Definition: Type.h:4413
StmtVisitor.h
clang::ASTNodeTraverser::VisitVarTemplateDecl
void VisitVarTemplateDecl(const VarTemplateDecl *D)
Definition: ASTNodeTraverser.h:521
clang::SplitQualType::Quals
Qualifiers Quals
The local qualifiers.
Definition: Type.h:598
clang::TypeAliasTemplateDecl
Declaration of an alias template.
Definition: DeclTemplate.h:2511
clang::ASTNodeTraverser::VisitOMPThreadPrivateDecl
void VisitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Definition: ASTNodeTraverser.h:427
clang::OMPAllocateDecl::clauselists
clauselist_range clauselists()
Definition: DeclOpenMP.h:502
clang::ASTNodeTraverser::VisitEnumConstantDecl
void VisitEnumConstantDecl(const EnumConstantDecl *D)
Definition: ASTNodeTraverser.h:374
clang::VectorType
Represents a GCC generic vector type.
Definition: Type.h:3235
clang::TemplateTemplateParmDecl
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Definition: DeclTemplate.h:1600
clang::LambdaExpr::getCallOperator
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
Definition: ExprCXX.cpp:1287
clang::StaticAssertDecl::getAssertExpr
Expr * getAssertExpr()
Definition: DeclCXX.h:3786
clang::ASTNodeTraverser::VisitBindingDecl
void VisitBindingDecl(const BindingDecl *D)
Definition: ASTNodeTraverser.h:416
CommentVisitor.h
clang::TemplateTemplateParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1731
clang::TypeOfExprType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4309
clang::ASTNodeTraverser::SetTraversalKind
void SetTraversalKind(ast_type_traits::TraversalKind TK)
Definition: ASTNodeTraverser.h:80
clang::ASTNodeTraverser::VisitOMPDeclareReductionDecl
void VisitOMPDeclareReductionDecl(const OMPDeclareReductionDecl *D)
Definition: ASTNodeTraverser.h:432
clang::ASTNodeTraverser::VisitDecltypeType
void VisitDecltypeType(const DecltypeType *T)
Definition: ASTNodeTraverser.h:335
clang::Qualifiers::hasQualifiers
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition: Type.h:420
clang::QualType::split
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:6264
clang::DeclaratorDecl::getTrailingRequiresClause
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:747
clang::attrvisitor::Base< llvm::make_const_ptr, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(PTR(Attr) A)
Definition: AttrVisitor.h:31
clang::ASTNodeTraverser::VisitReferenceType
void VisitReferenceType(const ReferenceType *T)
Definition: ASTNodeTraverser.h:305
clang::ASTNodeTraverser::VisitClassScopeFunctionSpecializationDecl
void VisitClassScopeFunctionSpecializationDecl(const ClassScopeFunctionSpecializationDecl *D)
Definition: ASTNodeTraverser.h:516
clang::OpaqueValueExpr
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1075
clang::CapturedStmt
This captures a statement into a function.
Definition: Stmt.h:3376
clang::ASTNodeTraverser::VisitPipeType
void VisitPipeType(const PipeType *T)
Definition: ASTNodeTraverser.h:363
clang::ASTNodeTraverser::VisitVarDecl
void VisitVarDecl(const VarDecl *D)
Definition: ASTNodeTraverser.h:405
clang::ASTNodeTraverser::VisitArrayType
void VisitArrayType(const ArrayType *T)
Definition: ASTNodeTraverser.h:312
clang::ASTNodeTraverser::Visit
void Visit(const ast_type_traits::DynTypedNode &N)
Definition: ASTNodeTraverser.h:231
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3680
clang::ASTNodeTraverser::VisitObjCCategoryDecl
void VisitObjCCategoryDecl(const ObjCCategoryDecl *D)
Definition: ASTNodeTraverser.h:593
clang::OMPDeclareReductionDecl
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
clang::OMPCapturedExprDecl
Pseudo declaration for capturing expressions.
Definition: DeclOpenMP.h:312
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
clang::ObjCCategoryDecl::getTypeParamList
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameter list associated with this category or extension.
Definition: DeclObjC.h:2344
clang::ASTNodeTraverser::VisitDecompositionDecl
void VisitDecompositionDecl(const DecompositionDecl *D)
Definition: ASTNodeTraverser.h:410
clang::ASTNodeTraverser::VisitOpaqueValueExpr
void VisitOpaqueValueExpr(const OpaqueValueExpr *Node)
Definition: ASTNodeTraverser.h:646
clang::SubstTemplateTypeParmPackType::getArgumentPack
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3403
clang::Decl::getASTContext
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:377
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3270
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1225
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:2876
clang::ASTNodeTraverser::Visit
void Visit(const TemplateArgument &A, SourceRange R={}, const Decl *From=nullptr, const char *Label=nullptr)
Definition: ASTNodeTraverser.h:182
clang::ASTNodeTraverser::VisitDeclStmt
void VisitDeclStmt(const DeclStmt *Node)
Definition: ASTNodeTraverser.h:615
clang::ObjCMethodDecl::getBody
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:855
clang::ASTNodeTraverser::VisitLocInfoType
void VisitLocInfoType(const LocInfoType *T)
Definition: ASTNodeTraverser.h:298
clang::ASTNodeTraverser::VisitFunctionType
void VisitFunctionType(const FunctionType *T)
Definition: ASTNodeTraverser.h:326
clang::ASTNodeTraverser::VisitSubstTemplateTypeParmPackType
void VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T)
Definition: ASTNodeTraverser.h:349
clang::Type::getLocallyUnqualifiedSingleStepDesugaredType
QualType getLocallyUnqualifiedSingleStepDesugaredType() const
Pull a single level of sugar off of this locally-unqualified type.
Definition: Type.cpp:354
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2294
clang::OMPClause
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:51
clang::SubstTemplateTypeParmPackType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4802
clang::LambdaExpr::capture_size
unsigned capture_size() const
Determine the number of captures in this lambda.
Definition: ExprCXX.h:1919
clang::comments::Comment::child_iterator
Comment *const * child_iterator
Definition: Comment.h:224
clang::TemplateTemplateParmDecl::hasDefaultArgument
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Definition: DeclTemplate.h:1718
clang::ASTNodeTraverser
ASTNodeTraverser traverses the Clang AST for dumping purposes.
Definition: ASTNodeTraverser.h:55
clang::comments::CommentVisitorBase< llvm::make_const_ptr, Derived, void, ParamTys... >::visit
void visit(PTR(Comment) C, ParamTys... P)
Definition: CommentVisitor.h:27
clang::ASTNodeTraverser::VisitClassTemplateDecl
void VisitClassTemplateDecl(const ClassTemplateDecl *D)
Definition: ASTNodeTraverser.h:501
clang::DefaultArgStorage::getInheritedFrom
const ParmDecl * getInheritedFrom() const
Get the parameter from which we inherit the default argument, if any.
Definition: DeclTemplate.h:362
clang::AtomicType
Definition: Type.h:6125
clang::StaticAssertDecl
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3763
clang::ASTNodeTraverser::VisitComplexType
void VisitComplexType(const ComplexType *T)
Definition: ASTNodeTraverser.h:297
clang::InitListExpr::getArrayFiller
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4497
clang::ASTNodeTraverser::setDeserialize
void setDeserialize(bool D)
Definition: ASTNodeTraverser.h:77
AttrVisitor.h
clang::VarTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2916
clang::PackExpansionType
Represents a pack expansion of types.
Definition: Type.h:5511
clang::TemplateArgument::pack_elements
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:353
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5234
clang::SizeOfPackExpr::getPartialArguments
ArrayRef< TemplateArgument > getPartialArguments() const
Get.
Definition: ExprCXX.h:4184
Node
ast_type_traits::DynTypedNode Node
Definition: ASTMatchFinder.cpp:60
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:50
clang::AdjustedType
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2662
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::ASTNodeTraverser::VisitBuiltinTemplateDecl
void VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D)
Definition: ASTNodeTraverser.h:523
clang::ConceptDecl
Definition: DeclTemplate.h:3226
clang::LocInfoType::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: LocInfoType.h:48
clang::TemplateArgumentLoc::getArgument
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:4164
clang::ASTNodeTraverser::Visit
void Visit(const Attr *A)
Definition: ASTNodeTraverser.h:168
clang::TemplateDecl
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:402
clang::ASTNodeTraverser::VisitAtomicType
void VisitAtomicType(const AtomicType *T)
Definition: ASTNodeTraverser.h:362
clang::ASTNodeTraverser::VisitStaticAssertDecl
void VisitStaticAssertDecl(const StaticAssertDecl *D)
Definition: ASTNodeTraverser.h:492
clang::AttributedStmt::getAttrs
ArrayRef< const Attr * > getAttrs() const
Definition: Stmt.h:1812
clang::Decl::attrs
attr_range attrs() const
Definition: DeclBase.h:501
clang::ASTNodeTraverser::VisitConceptDecl
void VisitConceptDecl(const ConceptDecl *D)
Definition: ASTNodeTraverser.h:567
clang::ClassTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2066
clang::TypedefNameDecl::getUnderlyingType
QualType getUnderlyingType() const
Definition: Decl.h:3126
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1229
clang::DecompositionDecl
A decomposition declaration.
Definition: DeclCXX.h:3869
clang::ASTNodeTraverser::VisitPointerType
void VisitPointerType(const PointerType *T)
Definition: ASTNodeTraverser.h:301
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2833
clang::NonTypeTemplateParmDecl::getDefaultArgument
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1465
clang::TemplateTypeParmDecl::defaultArgumentWasInherited
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Definition: DeclTemplate.h:1265
clang::ASTNodeTraverser::VisitTypeAliasDecl
void VisitTypeAliasDecl(const TypeAliasDecl *D)
Definition: ASTNodeTraverser.h:483
clang::LambdaExpr::getTemplateParameterList
TemplateParameterList * getTemplateParameterList() const
If this is a generic lambda expression, retrieve the template parameter list associated with it...
Definition: ExprCXX.cpp:1297
clang::ASTNodeTraverser::VisitMemberPointerType
void VisitMemberPointerType(const MemberPointerType *T)
Definition: ASTNodeTraverser.h:308
clang::SubstTemplateTypeParmType::getReplacedParameter
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4743
clang::TemplateTypeParmDecl::getDefaultArgStorage
const DefArgStorage & getDefaultArgStorage() const
Definition: DeclTemplate.h:1244
clang::ast_type_traits::DynTypedNode
A dynamically typed AST node container.
Definition: ASTTypeTraits.h:230
clang::AttributedType::getModifiedType
QualType getModifiedType() const
Definition: Type.h:4575
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:5951
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2716
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
clang::ASTNodeTraverser::VisitOMPCapturedExprDecl
void VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D)
Definition: ASTNodeTraverser.h:443
clang::ComplexType
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
clang::declvisitor::Base< llvm::make_const_ptr, ImplClass, RetTy >::Visit
RetTy Visit(PTR(Decl) D)
Definition: DeclVisitor.h:37
clang::ASTContext::getLocalCommentForDeclUncached
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:552
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2155
clang::ASTNodeTraverser::VisitClassTemplatePartialSpecializationDecl
void VisitClassTemplatePartialSpecializationDecl(const ClassTemplatePartialSpecializationDecl *D)
Definition: ASTNodeTraverser.h:510
clang::ObjCMethodDecl::hasBody
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:516
clang::ast_type_traits::TraversalKind
TraversalKind
Defines how we descend a level in the AST when we pass through expressions.
Definition: ASTTypeTraits.h:40
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
clang::DeclStmt::decls
decl_range decls()
Definition: Stmt.h:1273
clang::TemplateTemplateParmDecl::getDefaultArgument
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1721
clang::ASTNodeTraverser::VisitClassTemplateSpecializationDecl
void VisitClassTemplateSpecializationDecl(const ClassTemplateSpecializationDecl *D)
Definition: ASTNodeTraverser.h:505
clang::SizeOfPackExpr::isPartiallySubstituted
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:4179
clang::ASTNodeTraverser::Visit
void Visit(const BlockDecl::Capture &C)
Definition: ASTNodeTraverser.h:190
clang::ASTNodeTraverser::VisitVarTemplateSpecializationDecl
void VisitVarTemplateSpecializationDecl(const VarTemplateSpecializationDecl *D)
Definition: ASTNodeTraverser.h:528
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:239
clang::CapturedStmt::getCapturedDecl
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Definition: Stmt.cpp:1298
clang::AttributedType
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4550
clang::ASTNodeTraverser::dumpDeclContext
void dumpDeclContext(const DeclContext *DC)
Definition: ASTNodeTraverser.h:249
clang::FileScopeAsmDecl
Definition: Decl.h:4002
clang::PackExpansionType::isSugared
bool isSugared() const
Definition: Type.h:5542
clang::CXXCatchStmt
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
clang::ObjCSubstitutionContext::Parameter
The parameter type of a method or function.
clang::AttrSyntax::C
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2238
clang::ObjCTypeParamList
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:649
clang::ClassScopeFunctionSpecializationDecl::getSpecialization
CXXMethodDecl * getSpecialization() const
Definition: DeclTemplate.h:2614
clang::OMPDeclareMapperDecl
This represents &#39;#pragma omp declare mapper ...&#39; directive.
Definition: DeclOpenMP.h:217
clang::ASTNodeTraverser::VisitVectorType
void VisitVectorType(const VectorType *T)
Definition: ASTNodeTraverser.h:325
clang::ASTNodeTraverser::VisitDependentSizedExtVectorType
void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T)
Definition: ASTNodeTraverser.h:321
clang::OMPAllocateDecl::varlists
varlist_range varlists()
Definition: DeclOpenMP.h:491
clang::FunctionDecl::doesThisDeclarationHaveABody
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2078
clang::ASTNodeTraverser::VisitSubstTemplateTypeParmType
void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T)
Definition: ASTNodeTraverser.h:345
clang::StmtVisitorBase< llvm::make_const_ptr, ImplClass, RetTy, ParamTys... >::Visit
RetTy Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:43
clang::LambdaExpr::capture_begin
capture_iterator capture_begin() const
Retrieve an iterator pointing to the first lambda capture.
Definition: ExprCXX.cpp:1245
clang::TemplateSpecializationType
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
clang::BlockDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:4123
clang::BindingDecl::getBinding
Expr * getBinding() const
Get the expression to which this declaration is bound.
Definition: DeclCXX.h:3836
clang::ObjCAtCatchStmt::getCatchParamDecl
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:97
clang::ASTNodeTraverser::VisitLambdaExpr
void VisitLambdaExpr(const LambdaExpr *Node)
Definition: ASTNodeTraverser.h:660
clang::OMPThreadPrivateDecl::varlists
varlist_range varlists()
Definition: DeclOpenMP.h:77
clang::TemplateTypeParmDecl::getDefaultArgument
QualType getDefaultArgument() const
Retrieve the default argument, if any.
Definition: DeclTemplate.h:1251
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::ASTNodeTraverser::VisitDependentSizedArrayType
void VisitDependentSizedArrayType(const DependentSizedArrayType *T)
Definition: ASTNodeTraverser.h:317
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3039
clang::ASTNodeTraverser::VisitTemplateTypeParmDecl
void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D)
Definition: ASTNodeTraverser.h:539
clang::ConceptDecl::getConstraintExpr
Expr * getConstraintExpr() const
Definition: DeclTemplate.h:3241
clang::comments::ConstCommentVisitor
Definition: CommentVisitor.h:62
clang::ConstDeclVisitor
A simple visitor class that helps create declaration visitors.
Definition: DeclVisitor.h:73
clang::VarDecl::hasInit
bool hasInit() const
Definition: Decl.cpp:2226
clang::OMPThreadPrivateDecl
This represents &#39;#pragma omp threadprivate ...&#39; directive.
Definition: DeclOpenMP.h:39
clang::ASTNodeTraverser::VisitUnaryTransformType
void VisitUnaryTransformType(const UnaryTransformType *T)
Definition: ASTNodeTraverser.h:338
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:977
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:45
clang::FileScopeAsmDecl::getAsmString
const StringLiteral * getAsmString() const
Definition: Decl.h:4026
clang::MemberPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2853
clang::UsingShadowDecl
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3162
clang::comments::FullComment
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1093
clang::ASTNodeTraverser::VisitTypedefDecl
void VisitTypedefDecl(const TypedefDecl *D)
Definition: ASTNodeTraverser.h:372
clang::TypeSourceInfo::getType
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6238
clang::GenericSelectionExpr::associations
association_range associations()
Definition: Expr.h:5463
clang::ObjCMethodDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:368
clang::StmtVisitorBase< llvm::make_const_ptr, Derived, void, ParamTys... >::P
ParamTys P
Definition: StmtVisitor.h:171
clang::ObjCImplementationDecl::inits
init_range inits()
Definition: DeclObjC.h:2628
clang::DependentSizedExtVectorType::getSizeExpr
Expr * getSizeExpr() const
Definition: Type.h:3210
clang::ASTNodeTraverser::VisitObjCImplementationDecl
void VisitObjCImplementationDecl(const ObjCImplementationDecl *D)
Definition: ASTNodeTraverser.h:601
clang::ObjCObjectPointerType::getPointeeType
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5967