clang  15.0.0git
RecursiveASTVisitor.h
Go to the documentation of this file.
1 //===--- RecursiveASTVisitor.h - Recursive AST Visitor ----------*- C++ -*-===//
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 defines the RecursiveASTVisitor interface, which recursively
10 // traverses the entire AST.
11 //
12 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
14 #define LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
15 
16 #include "clang/AST/ASTConcept.h"
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclBase.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclFriend.h"
22 #include "clang/AST/DeclObjC.h"
23 #include "clang/AST/DeclOpenMP.h"
24 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/Expr.h"
27 #include "clang/AST/ExprCXX.h"
28 #include "clang/AST/ExprConcepts.h"
29 #include "clang/AST/ExprObjC.h"
30 #include "clang/AST/ExprOpenMP.h"
33 #include "clang/AST/OpenMPClause.h"
34 #include "clang/AST/Stmt.h"
35 #include "clang/AST/StmtCXX.h"
36 #include "clang/AST/StmtObjC.h"
37 #include "clang/AST/StmtOpenMP.h"
38 #include "clang/AST/TemplateBase.h"
39 #include "clang/AST/TemplateName.h"
40 #include "clang/AST/Type.h"
41 #include "clang/AST/TypeLoc.h"
42 #include "clang/Basic/LLVM.h"
44 #include "clang/Basic/Specifiers.h"
45 #include "llvm/ADT/PointerIntPair.h"
46 #include "llvm/ADT/SmallVector.h"
47 #include "llvm/Support/Casting.h"
48 #include <algorithm>
49 #include <cstddef>
50 #include <type_traits>
51 
52 namespace clang {
53 
54 // A helper macro to implement short-circuiting when recursing. It
55 // invokes CALL_EXPR, which must be a method call, on the derived
56 // object (s.t. a user of RecursiveASTVisitor can override the method
57 // in CALL_EXPR).
58 #define TRY_TO(CALL_EXPR) \
59  do { \
60  if (!getDerived().CALL_EXPR) \
61  return false; \
62  } while (false)
63 
64 namespace detail {
65 
66 template <typename T, typename U>
67 struct has_same_member_pointer_type : std::false_type {};
68 template <typename T, typename U, typename R, typename... P>
69 struct has_same_member_pointer_type<R (T::*)(P...), R (U::*)(P...)>
70  : std::true_type {};
71 
72 template <bool has_same_type> struct is_same_method_impl {
73  template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
74  static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
75  SecondMethodPtrTy SecondMethodPtr) {
76  return false;
77  }
78 };
79 
80 template <> struct is_same_method_impl<true> {
81  template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
82  static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
83  SecondMethodPtrTy SecondMethodPtr) {
84  return FirstMethodPtr == SecondMethodPtr;
85  }
86 };
87 
88 /// Returns true if and only if \p FirstMethodPtr and \p SecondMethodPtr
89 /// are pointers to the same non-static member function.
90 template <typename FirstMethodPtrTy, typename SecondMethodPtrTy>
91 bool isSameMethod(FirstMethodPtrTy FirstMethodPtr,
92  SecondMethodPtrTy SecondMethodPtr) {
94  FirstMethodPtrTy,
95  SecondMethodPtrTy>::value>::isSameMethod(FirstMethodPtr, SecondMethodPtr);
96 }
97 
98 } // end namespace detail
99 
100 /// A class that does preorder or postorder
101 /// depth-first traversal on the entire Clang AST and visits each node.
102 ///
103 /// This class performs three distinct tasks:
104 /// 1. traverse the AST (i.e. go to each node);
105 /// 2. at a given node, walk up the class hierarchy, starting from
106 /// the node's dynamic type, until the top-most class (e.g. Stmt,
107 /// Decl, or Type) is reached.
108 /// 3. given a (node, class) combination, where 'class' is some base
109 /// class of the dynamic type of 'node', call a user-overridable
110 /// function to actually visit the node.
111 ///
112 /// These tasks are done by three groups of methods, respectively:
113 /// 1. TraverseDecl(Decl *x) does task #1. It is the entry point
114 /// for traversing an AST rooted at x. This method simply
115 /// dispatches (i.e. forwards) to TraverseFoo(Foo *x) where Foo
116 /// is the dynamic type of *x, which calls WalkUpFromFoo(x) and
117 /// then recursively visits the child nodes of x.
118 /// TraverseStmt(Stmt *x) and TraverseType(QualType x) work
119 /// similarly.
120 /// 2. WalkUpFromFoo(Foo *x) does task #2. It does not try to visit
121 /// any child node of x. Instead, it first calls WalkUpFromBar(x)
122 /// where Bar is the direct parent class of Foo (unless Foo has
123 /// no parent), and then calls VisitFoo(x) (see the next list item).
124 /// 3. VisitFoo(Foo *x) does task #3.
125 ///
126 /// These three method groups are tiered (Traverse* > WalkUpFrom* >
127 /// Visit*). A method (e.g. Traverse*) may call methods from the same
128 /// tier (e.g. other Traverse*) or one tier lower (e.g. WalkUpFrom*).
129 /// It may not call methods from a higher tier.
130 ///
131 /// Note that since WalkUpFromFoo() calls WalkUpFromBar() (where Bar
132 /// is Foo's super class) before calling VisitFoo(), the result is
133 /// that the Visit*() methods for a given node are called in the
134 /// top-down order (e.g. for a node of type NamespaceDecl, the order will
135 /// be VisitDecl(), VisitNamedDecl(), and then VisitNamespaceDecl()).
136 ///
137 /// This scheme guarantees that all Visit*() calls for the same AST
138 /// node are grouped together. In other words, Visit*() methods for
139 /// different nodes are never interleaved.
140 ///
141 /// Clients of this visitor should subclass the visitor (providing
142 /// themselves as the template argument, using the curiously recurring
143 /// template pattern) and override any of the Traverse*, WalkUpFrom*,
144 /// and Visit* methods for declarations, types, statements,
145 /// expressions, or other AST nodes where the visitor should customize
146 /// behavior. Most users only need to override Visit*. Advanced
147 /// users may override Traverse* and WalkUpFrom* to implement custom
148 /// traversal strategies. Returning false from one of these overridden
149 /// functions will abort the entire traversal.
150 ///
151 /// By default, this visitor tries to visit every part of the explicit
152 /// source code exactly once. The default policy towards templates
153 /// is to descend into the 'pattern' class or function body, not any
154 /// explicit or implicit instantiations. Explicit specializations
155 /// are still visited, and the patterns of partial specializations
156 /// are visited separately. This behavior can be changed by
157 /// overriding shouldVisitTemplateInstantiations() in the derived class
158 /// to return true, in which case all known implicit and explicit
159 /// instantiations will be visited at the same time as the pattern
160 /// from which they were produced.
161 ///
162 /// By default, this visitor preorder traverses the AST. If postorder traversal
163 /// is needed, the \c shouldTraversePostOrder method needs to be overridden
164 /// to return \c true.
165 template <typename Derived> class RecursiveASTVisitor {
166 public:
167  /// A queue used for performing data recursion over statements.
168  /// Parameters involving this type are used to implement data
169  /// recursion over Stmts and Exprs within this class, and should
170  /// typically not be explicitly specified by derived classes.
171  /// The bool bit indicates whether the statement has been traversed or not.
174 
175  /// Return a reference to the derived class.
176  Derived &getDerived() { return *static_cast<Derived *>(this); }
177 
178  /// Return whether this visitor should recurse into
179  /// template instantiations.
180  bool shouldVisitTemplateInstantiations() const { return false; }
181 
182  /// Return whether this visitor should recurse into the types of
183  /// TypeLocs.
184  bool shouldWalkTypesOfTypeLocs() const { return true; }
185 
186  /// Return whether this visitor should recurse into implicit
187  /// code, e.g., implicit constructors and destructors.
188  bool shouldVisitImplicitCode() const { return false; }
189 
190  /// Return whether this visitor should recurse into lambda body
191  bool shouldVisitLambdaBody() const { return true; }
192 
193  /// Return whether this visitor should traverse post-order.
194  bool shouldTraversePostOrder() const { return false; }
195 
196  /// Recursively visits an entire AST, starting from the TranslationUnitDecl.
197  /// \returns false if visitation was terminated early.
198  bool TraverseAST(ASTContext &AST) {
199  // Currently just an alias for TraverseDecl(TUDecl), but kept in case
200  // we change the implementation again.
201  return getDerived().TraverseDecl(AST.getTranslationUnitDecl());
202  }
203 
204  /// Recursively visit a statement or expression, by
205  /// dispatching to Traverse*() based on the argument's dynamic type.
206  ///
207  /// \returns false if the visitation was terminated early, true
208  /// otherwise (including when the argument is nullptr).
209  bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = nullptr);
210 
211  /// Invoked before visiting a statement or expression via data recursion.
212  ///
213  /// \returns false to skip visiting the node, true otherwise.
214  bool dataTraverseStmtPre(Stmt *S) { return true; }
215 
216  /// Invoked after visiting a statement or expression via data recursion.
217  /// This is not invoked if the previously invoked \c dataTraverseStmtPre
218  /// returned false.
219  ///
220  /// \returns false if the visitation was terminated early, true otherwise.
221  bool dataTraverseStmtPost(Stmt *S) { return true; }
222 
223  /// Recursively visit a type, by dispatching to
224  /// Traverse*Type() based on the argument's getTypeClass() property.
225  ///
226  /// \returns false if the visitation was terminated early, true
227  /// otherwise (including when the argument is a Null type).
228  bool TraverseType(QualType T);
229 
230  /// Recursively visit a type with location, by dispatching to
231  /// Traverse*TypeLoc() based on the argument type's getTypeClass() property.
232  ///
233  /// \returns false if the visitation was terminated early, true
234  /// otherwise (including when the argument is a Null type location).
235  bool TraverseTypeLoc(TypeLoc TL);
236 
237  /// Recursively visit an attribute, by dispatching to
238  /// Traverse*Attr() based on the argument's dynamic type.
239  ///
240  /// \returns false if the visitation was terminated early, true
241  /// otherwise (including when the argument is a Null type location).
242  bool TraverseAttr(Attr *At);
243 
244  /// Recursively visit a declaration, by dispatching to
245  /// Traverse*Decl() based on the argument's dynamic type.
246  ///
247  /// \returns false if the visitation was terminated early, true
248  /// otherwise (including when the argument is NULL).
249  bool TraverseDecl(Decl *D);
250 
251  /// Recursively visit a C++ nested-name-specifier.
252  ///
253  /// \returns false if the visitation was terminated early, true otherwise.
255 
256  /// Recursively visit a C++ nested-name-specifier with location
257  /// information.
258  ///
259  /// \returns false if the visitation was terminated early, true otherwise.
261 
262  /// Recursively visit a name with its location information.
263  ///
264  /// \returns false if the visitation was terminated early, true otherwise.
266 
267  /// Recursively visit a template name and dispatch to the
268  /// appropriate method.
269  ///
270  /// \returns false if the visitation was terminated early, true otherwise.
271  bool TraverseTemplateName(TemplateName Template);
272 
273  /// Recursively visit a template argument and dispatch to the
274  /// appropriate method for the argument type.
275  ///
276  /// \returns false if the visitation was terminated early, true otherwise.
277  // FIXME: migrate callers to TemplateArgumentLoc instead.
279 
280  /// Recursively visit a template argument location and dispatch to the
281  /// appropriate method for the argument type.
282  ///
283  /// \returns false if the visitation was terminated early, true otherwise.
285 
286  /// Recursively visit a set of template arguments.
287  /// This can be overridden by a subclass, but it's not expected that
288  /// will be needed -- this visitor always dispatches to another.
289  ///
290  /// \returns false if the visitation was terminated early, true otherwise.
291  // FIXME: take a TemplateArgumentLoc* (or TemplateArgumentListInfo) instead.
293  unsigned NumArgs);
294 
295  /// Recursively visit a base specifier. This can be overridden by a
296  /// subclass.
297  ///
298  /// \returns false if the visitation was terminated early, true otherwise.
300 
301  /// Recursively visit a constructor initializer. This
302  /// automatically dispatches to another visitor for the initializer
303  /// expression, but not for the name of the initializer, so may
304  /// be overridden for clients that need access to the name.
305  ///
306  /// \returns false if the visitation was terminated early, true otherwise.
308 
309  /// Recursively visit a lambda capture. \c Init is the expression that
310  /// will be used to initialize the capture.
311  ///
312  /// \returns false if the visitation was terminated early, true otherwise.
314  Expr *Init);
315 
316  /// Recursively visit the syntactic or semantic form of an
317  /// initialization list.
318  ///
319  /// \returns false if the visitation was terminated early, true otherwise.
321  DataRecursionQueue *Queue = nullptr);
322 
323  /// Recursively visit an Objective-C protocol reference with location
324  /// information.
325  ///
326  /// \returns false if the visitation was terminated early, true otherwise.
327  bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc);
328 
329  // ---- Methods on Attrs ----
330 
331  // Visit an attribute.
332  bool VisitAttr(Attr *A) { return true; }
333 
334 // Declare Traverse* and empty Visit* for all Attr classes.
335 #define ATTR_VISITOR_DECLS_ONLY
336 #include "clang/AST/AttrVisitor.inc"
337 #undef ATTR_VISITOR_DECLS_ONLY
338 
339 // ---- Methods on Stmts ----
340 
341  Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
342 
343 private:
344  // Traverse the given statement. If the most-derived traverse function takes a
345  // data recursion queue, pass it on; otherwise, discard it. Note that the
346  // first branch of this conditional must compile whether or not the derived
347  // class can take a queue, so if we're taking the second arm, make the first
348  // arm call our function rather than the derived class version.
349 #define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE) \
350  (::clang::detail::has_same_member_pointer_type< \
351  decltype(&RecursiveASTVisitor::Traverse##NAME), \
352  decltype(&Derived::Traverse##NAME)>::value \
353  ? static_cast<std::conditional_t< \
354  ::clang::detail::has_same_member_pointer_type< \
355  decltype(&RecursiveASTVisitor::Traverse##NAME), \
356  decltype(&Derived::Traverse##NAME)>::value, \
357  Derived &, RecursiveASTVisitor &>>(*this) \
358  .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE) \
359  : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)))
360 
361 // Try to traverse the given statement, or enqueue it if we're performing data
362 // recursion in the middle of traversing another statement. Can only be called
363 // from within a DEF_TRAVERSE_STMT body or similar context.
364 #define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S) \
365  do { \
366  if (!TRAVERSE_STMT_BASE(Stmt, Stmt, S, Queue)) \
367  return false; \
368  } while (false)
369 
370 public:
371 // Declare Traverse*() for all concrete Stmt classes.
372 #define ABSTRACT_STMT(STMT)
373 #define STMT(CLASS, PARENT) \
374  bool Traverse##CLASS(CLASS *S, DataRecursionQueue *Queue = nullptr);
375 #include "clang/AST/StmtNodes.inc"
376  // The above header #undefs ABSTRACT_STMT and STMT upon exit.
377 
378  // Define WalkUpFrom*() and empty Visit*() for all Stmt classes.
379  bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); }
380  bool VisitStmt(Stmt *S) { return true; }
381 #define STMT(CLASS, PARENT) \
382  bool WalkUpFrom##CLASS(CLASS *S) { \
383  TRY_TO(WalkUpFrom##PARENT(S)); \
384  TRY_TO(Visit##CLASS(S)); \
385  return true; \
386  } \
387  bool Visit##CLASS(CLASS *S) { return true; }
388 #include "clang/AST/StmtNodes.inc"
389 
390 // ---- Methods on Types ----
391 // FIXME: revamp to take TypeLoc's rather than Types.
392 
393 // Declare Traverse*() for all concrete Type classes.
394 #define ABSTRACT_TYPE(CLASS, BASE)
395 #define TYPE(CLASS, BASE) bool Traverse##CLASS##Type(CLASS##Type *T);
396 #include "clang/AST/TypeNodes.inc"
397  // The above header #undefs ABSTRACT_TYPE and TYPE upon exit.
398 
399  // Define WalkUpFrom*() and empty Visit*() for all Type classes.
400  bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); }
401  bool VisitType(Type *T) { return true; }
402 #define TYPE(CLASS, BASE) \
403  bool WalkUpFrom##CLASS##Type(CLASS##Type *T) { \
404  TRY_TO(WalkUpFrom##BASE(T)); \
405  TRY_TO(Visit##CLASS##Type(T)); \
406  return true; \
407  } \
408  bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
409 #include "clang/AST/TypeNodes.inc"
410 
411 // ---- Methods on TypeLocs ----
412 // FIXME: this currently just calls the matching Type methods
413 
414 // Declare Traverse*() for all concrete TypeLoc classes.
415 #define ABSTRACT_TYPELOC(CLASS, BASE)
416 #define TYPELOC(CLASS, BASE) bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);
417 #include "clang/AST/TypeLocNodes.def"
418  // The above header #undefs ABSTRACT_TYPELOC and TYPELOC upon exit.
419 
420  // Define WalkUpFrom*() and empty Visit*() for all TypeLoc classes.
421  bool WalkUpFromTypeLoc(TypeLoc TL) { return getDerived().VisitTypeLoc(TL); }
422  bool VisitTypeLoc(TypeLoc TL) { return true; }
423 
424  // QualifiedTypeLoc and UnqualTypeLoc are not declared in
425  // TypeNodes.inc and thus need to be handled specially.
427  return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
428  }
429  bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { return true; }
431  return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
432  }
433  bool VisitUnqualTypeLoc(UnqualTypeLoc TL) { return true; }
434 
435 // Note that BASE includes trailing 'Type' which CLASS doesn't.
436 #define TYPE(CLASS, BASE) \
437  bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
438  TRY_TO(WalkUpFrom##BASE##Loc(TL)); \
439  TRY_TO(Visit##CLASS##TypeLoc(TL)); \
440  return true; \
441  } \
442  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }
443 #include "clang/AST/TypeNodes.inc"
444 
445 // ---- Methods on Decls ----
446 
447 // Declare Traverse*() for all concrete Decl classes.
448 #define ABSTRACT_DECL(DECL)
449 #define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);
450 #include "clang/AST/DeclNodes.inc"
451  // The above header #undefs ABSTRACT_DECL and DECL upon exit.
452 
453  // Define WalkUpFrom*() and empty Visit*() for all Decl classes.
454  bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); }
455  bool VisitDecl(Decl *D) { return true; }
456 #define DECL(CLASS, BASE) \
457  bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) { \
458  TRY_TO(WalkUpFrom##BASE(D)); \
459  TRY_TO(Visit##CLASS##Decl(D)); \
460  return true; \
461  } \
462  bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
463 #include "clang/AST/DeclNodes.inc"
464 
465  bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child);
466 
467 #define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND) \
468  bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D);
471  DEF_TRAVERSE_TMPL_INST(Function)
472 #undef DEF_TRAVERSE_TMPL_INST
473 
474  bool TraverseTypeConstraint(const TypeConstraint *C);
475 
476  bool TraverseConceptRequirement(concepts::Requirement *R);
477  bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R);
478  bool TraverseConceptExprRequirement(concepts::ExprRequirement *R);
479  bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R);
480 
481  bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
482 
483 private:
484  // These are helper methods used by more than one Traverse* method.
485  bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
486  /// Traverses the qualifier, name and template arguments of a concept
487  /// reference.
488  bool TraverseConceptReferenceHelper(const ConceptReference &C);
489 
490  // Traverses template parameter lists of either a DeclaratorDecl or TagDecl.
491  template <typename T>
492  bool TraverseDeclTemplateParameterLists(T *D);
493 
494  bool TraverseTemplateTypeParamDeclConstraints(const TemplateTypeParmDecl *D);
495 
496  bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
497  unsigned Count);
498  bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
499  bool TraverseRecordHelper(RecordDecl *D);
500  bool TraverseCXXRecordHelper(CXXRecordDecl *D);
501  bool TraverseDeclaratorHelper(DeclaratorDecl *D);
502  bool TraverseDeclContextHelper(DeclContext *DC);
503  bool TraverseFunctionHelper(FunctionDecl *D);
504  bool TraverseVarHelper(VarDecl *D);
505  bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
506  bool TraverseOMPLoopDirective(OMPLoopDirective *S);
507  bool TraverseOMPClause(OMPClause *C);
508 #define GEN_CLANG_CLAUSE_CLASS
509 #define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
510 #include "llvm/Frontend/OpenMP/OMP.inc"
511  /// Process clauses with list of variables.
512  template <typename T> bool VisitOMPClauseList(T *Node);
513  /// Process clauses with pre-initis.
514  bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
515  bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
516 
517  bool PostVisitStmt(Stmt *S);
518 };
519 
520 template <typename Derived>
522  const TypeConstraint *C) {
523  if (!getDerived().shouldVisitImplicitCode()) {
524  TRY_TO(TraverseConceptReferenceHelper(*C));
525  return true;
526  }
527  if (Expr *IDC = C->getImmediatelyDeclaredConstraint()) {
528  TRY_TO(TraverseStmt(IDC));
529  } else {
530  // Avoid traversing the ConceptReference in the TypeConstraint
531  // if we have an immediately-declared-constraint, otherwise
532  // we'll end up visiting the concept and the arguments in
533  // the TC twice.
534  TRY_TO(TraverseConceptReferenceHelper(*C));
535  }
536  return true;
537 }
538 
539 template <typename Derived>
542  switch (R->getKind()) {
544  return getDerived().TraverseConceptTypeRequirement(
545  cast<concepts::TypeRequirement>(R));
548  return getDerived().TraverseConceptExprRequirement(
549  cast<concepts::ExprRequirement>(R));
551  return getDerived().TraverseConceptNestedRequirement(
552  cast<concepts::NestedRequirement>(R));
553  }
554  llvm_unreachable("unexpected case");
555 }
556 
557 template <typename Derived>
559  const ConceptReference &C) {
560  TRY_TO(TraverseNestedNameSpecifierLoc(C.getNestedNameSpecifierLoc()));
561  TRY_TO(TraverseDeclarationNameInfo(C.getConceptNameInfo()));
562  if (C.hasExplicitTemplateArgs())
563  TRY_TO(TraverseTemplateArgumentLocsHelper(
564  C.getTemplateArgsAsWritten()->getTemplateArgs(),
565  C.getTemplateArgsAsWritten()->NumTemplateArgs));
566  return true;
567 }
568 
569 template <typename Derived>
571  DataRecursionQueue *Queue) {
572  // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt.
573  switch (S->getStmtClass()) {
574  case Stmt::NoStmtClass:
575  break;
576 #define ABSTRACT_STMT(STMT)
577 #define STMT(CLASS, PARENT) \
578  case Stmt::CLASS##Class: \
579  return TRAVERSE_STMT_BASE(CLASS, CLASS, S, Queue);
580 #include "clang/AST/StmtNodes.inc"
581  }
582 
583  return true;
584 }
585 
586 #undef DISPATCH_STMT
587 
588 template <typename Derived>
591  if (R->isSubstitutionFailure())
592  return true;
593  return getDerived().TraverseTypeLoc(R->getType()->getTypeLoc());
594 }
595 
596 template <typename Derived>
599  if (!R->isExprSubstitutionFailure())
600  TRY_TO(TraverseStmt(R->getExpr()));
601  auto &RetReq = R->getReturnTypeRequirement();
602  if (RetReq.isTypeConstraint()) {
603  if (getDerived().shouldVisitImplicitCode()) {
604  TRY_TO(TraverseTemplateParameterListHelper(
605  RetReq.getTypeConstraintTemplateParameterList()));
606  } else {
607  // Template parameter list is implicit, visit constraint directly.
608  TRY_TO(TraverseTypeConstraint(RetReq.getTypeConstraint()));
609  }
610  }
611  return true;
612 }
613 
614 template <typename Derived>
617  if (!R->isSubstitutionFailure())
618  return getDerived().TraverseStmt(R->getConstraintExpr());
619  return true;
620 }
621 
622 template <typename Derived>
624  // In pre-order traversal mode, each Traverse##STMT method is responsible for
625  // calling WalkUpFrom. Therefore, if the user overrides Traverse##STMT and
626  // does not call the default implementation, the WalkUpFrom callback is not
627  // called. Post-order traversal mode should provide the same behavior
628  // regarding method overrides.
629  //
630  // In post-order traversal mode the Traverse##STMT method, when it receives a
631  // DataRecursionQueue, can't call WalkUpFrom after traversing children because
632  // it only enqueues the children and does not traverse them. TraverseStmt
633  // traverses the enqueued children, and we call WalkUpFrom here.
634  //
635  // However, to make pre-order and post-order modes identical with regards to
636  // whether they call WalkUpFrom at all, we call WalkUpFrom if and only if the
637  // user did not override the Traverse##STMT method. We implement the override
638  // check with isSameMethod calls below.
639 
640  switch (S->getStmtClass()) {
641  case Stmt::NoStmtClass:
642  break;
643 #define ABSTRACT_STMT(STMT)
644 #define STMT(CLASS, PARENT) \
645  case Stmt::CLASS##Class: \
646  if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS, \
647  &Derived::Traverse##CLASS)) { \
648  TRY_TO(WalkUpFrom##CLASS(static_cast<CLASS *>(S))); \
649  } \
650  break;
651 #define INITLISTEXPR(CLASS, PARENT) \
652  case Stmt::CLASS##Class: \
653  if (::clang::detail::isSameMethod(&RecursiveASTVisitor::Traverse##CLASS, \
654  &Derived::Traverse##CLASS)) { \
655  auto ILE = static_cast<CLASS *>(S); \
656  if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE) \
657  TRY_TO(WalkUpFrom##CLASS(Syn)); \
658  if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm()) \
659  TRY_TO(WalkUpFrom##CLASS(Sem)); \
660  } \
661  break;
662 #include "clang/AST/StmtNodes.inc"
663  }
664 
665  return true;
666 }
667 
668 #undef DISPATCH_STMT
669 
670 template <typename Derived>
672  DataRecursionQueue *Queue) {
673  if (!S)
674  return true;
675 
676  if (Queue) {
677  Queue->push_back({S, false});
678  return true;
679  }
680 
682  LocalQueue.push_back({S, false});
683 
684  while (!LocalQueue.empty()) {
685  auto &CurrSAndVisited = LocalQueue.back();
686  Stmt *CurrS = CurrSAndVisited.getPointer();
687  bool Visited = CurrSAndVisited.getInt();
688  if (Visited) {
689  LocalQueue.pop_back();
690  TRY_TO(dataTraverseStmtPost(CurrS));
691  if (getDerived().shouldTraversePostOrder()) {
692  TRY_TO(PostVisitStmt(CurrS));
693  }
694  continue;
695  }
696 
697  if (getDerived().dataTraverseStmtPre(CurrS)) {
698  CurrSAndVisited.setInt(true);
699  size_t N = LocalQueue.size();
700  TRY_TO(dataTraverseNode(CurrS, &LocalQueue));
701  // Process new children in the order they were added.
702  std::reverse(LocalQueue.begin() + N, LocalQueue.end());
703  } else {
704  LocalQueue.pop_back();
705  }
706  }
707 
708  return true;
709 }
710 
711 template <typename Derived>
713  if (T.isNull())
714  return true;
715 
716  switch (T->getTypeClass()) {
717 #define ABSTRACT_TYPE(CLASS, BASE)
718 #define TYPE(CLASS, BASE) \
719  case Type::CLASS: \
720  return getDerived().Traverse##CLASS##Type( \
721  static_cast<CLASS##Type *>(const_cast<Type *>(T.getTypePtr())));
722 #include "clang/AST/TypeNodes.inc"
723  }
724 
725  return true;
726 }
727 
728 template <typename Derived>
730  if (TL.isNull())
731  return true;
732 
733  switch (TL.getTypeLocClass()) {
734 #define ABSTRACT_TYPELOC(CLASS, BASE)
735 #define TYPELOC(CLASS, BASE) \
736  case TypeLoc::CLASS: \
737  return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>());
738 #include "clang/AST/TypeLocNodes.def"
739  }
740 
741  return true;
742 }
743 
744 // Define the Traverse*Attr(Attr* A) methods
745 #define VISITORCLASS RecursiveASTVisitor
746 #include "clang/AST/AttrVisitor.inc"
747 #undef VISITORCLASS
748 
749 template <typename Derived>
751  if (!D)
752  return true;
753 
754  // As a syntax visitor, by default we want to ignore declarations for
755  // implicit declarations (ones not typed explicitly by the user).
756  if (!getDerived().shouldVisitImplicitCode() && D->isImplicit()) {
757  // For an implicit template type parameter, its type constraints are not
758  // implicit and are not represented anywhere else. We still need to visit
759  // them.
760  if (auto *TTPD = dyn_cast<TemplateTypeParmDecl>(D))
761  return TraverseTemplateTypeParamDeclConstraints(TTPD);
762  return true;
763  }
764 
765  switch (D->getKind()) {
766 #define ABSTRACT_DECL(DECL)
767 #define DECL(CLASS, BASE) \
768  case Decl::CLASS: \
769  if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D))) \
770  return false; \
771  break;
772 #include "clang/AST/DeclNodes.inc"
773  }
774  return true;
775 }
776 
777 template <typename Derived>
779  NestedNameSpecifier *NNS) {
780  if (!NNS)
781  return true;
782 
783  if (NNS->getPrefix())
784  TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix()));
785 
786  switch (NNS->getKind()) {
792  return true;
793 
796  TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
797  }
798 
799  return true;
800 }
801 
802 template <typename Derived>
805  if (!NNS)
806  return true;
807 
808  if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
809  TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
810 
811  switch (NNS.getNestedNameSpecifier()->getKind()) {
817  return true;
818 
821  TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
822  break;
823  }
824 
825  return true;
826 }
827 
828 template <typename Derived>
830  DeclarationNameInfo NameInfo) {
831  switch (NameInfo.getName().getNameKind()) {
835  if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
836  TRY_TO(TraverseTypeLoc(TSInfo->getTypeLoc()));
837  break;
838 
840  TRY_TO(TraverseTemplateName(
842  break;
843 
851  break;
852  }
853 
854  return true;
855 }
856 
857 template <typename Derived>
860  TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier()));
861  else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
862  TRY_TO(TraverseNestedNameSpecifier(QTN->getQualifier()));
863 
864  return true;
865 }
866 
867 template <typename Derived>
869  const TemplateArgument &Arg) {
870  switch (Arg.getKind()) {
875  return true;
876 
878  return getDerived().TraverseType(Arg.getAsType());
879 
882  return getDerived().TraverseTemplateName(
884 
886  return getDerived().TraverseStmt(Arg.getAsExpr());
887 
889  return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
890  Arg.pack_size());
891  }
892 
893  return true;
894 }
895 
896 // FIXME: no template name location?
897 // FIXME: no source locations for a template argument pack?
898 template <typename Derived>
900  const TemplateArgumentLoc &ArgLoc) {
901  const TemplateArgument &Arg = ArgLoc.getArgument();
902 
903  switch (Arg.getKind()) {
908  return true;
909 
910  case TemplateArgument::Type: {
911  // FIXME: how can TSI ever be NULL?
912  if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo())
913  return getDerived().TraverseTypeLoc(TSI->getTypeLoc());
914  else
915  return getDerived().TraverseType(Arg.getAsType());
916  }
917 
920  if (ArgLoc.getTemplateQualifierLoc())
921  TRY_TO(getDerived().TraverseNestedNameSpecifierLoc(
922  ArgLoc.getTemplateQualifierLoc()));
923  return getDerived().TraverseTemplateName(
925 
927  return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
928 
930  return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
931  Arg.pack_size());
932  }
933 
934  return true;
935 }
936 
937 template <typename Derived>
939  const TemplateArgument *Args, unsigned NumArgs) {
940  for (unsigned I = 0; I != NumArgs; ++I) {
941  TRY_TO(TraverseTemplateArgument(Args[I]));
942  }
943 
944  return true;
945 }
946 
947 template <typename Derived>
949  CXXCtorInitializer *Init) {
950  if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
951  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
952 
953  if (Init->isWritten() || getDerived().shouldVisitImplicitCode())
954  TRY_TO(TraverseStmt(Init->getInit()));
955 
956  return true;
957 }
958 
959 template <typename Derived>
960 bool
962  const LambdaCapture *C,
963  Expr *Init) {
964  if (LE->isInitCapture(C))
965  TRY_TO(TraverseDecl(C->getCapturedVar()));
966  else
967  TRY_TO(TraverseStmt(Init));
968  return true;
969 }
970 
971 // ----------------- Type traversal -----------------
972 
973 // This macro makes available a variable T, the passed-in type.
974 #define DEF_TRAVERSE_TYPE(TYPE, CODE) \
975  template <typename Derived> \
976  bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) { \
977  if (!getDerived().shouldTraversePostOrder()) \
978  TRY_TO(WalkUpFrom##TYPE(T)); \
979  { CODE; } \
980  if (getDerived().shouldTraversePostOrder()) \
981  TRY_TO(WalkUpFrom##TYPE(T)); \
982  return true; \
983  }
984 
985 DEF_TRAVERSE_TYPE(BuiltinType, {})
986 
987 DEF_TRAVERSE_TYPE(ComplexType, { TRY_TO(TraverseType(T->getElementType())); })
988 
989 DEF_TRAVERSE_TYPE(PointerType, { TRY_TO(TraverseType(T->getPointeeType())); })
990 
991 DEF_TRAVERSE_TYPE(BlockPointerType,
992  { TRY_TO(TraverseType(T->getPointeeType())); })
993 
994 DEF_TRAVERSE_TYPE(LValueReferenceType,
995  { TRY_TO(TraverseType(T->getPointeeType())); })
996 
997 DEF_TRAVERSE_TYPE(RValueReferenceType,
998  { TRY_TO(TraverseType(T->getPointeeType())); })
999 
1000 DEF_TRAVERSE_TYPE(MemberPointerType, {
1001  TRY_TO(TraverseType(QualType(T->getClass(), 0)));
1002  TRY_TO(TraverseType(T->getPointeeType()));
1003 })
1004 
1005 DEF_TRAVERSE_TYPE(AdjustedType, { TRY_TO(TraverseType(T->getOriginalType())); })
1006 
1007 DEF_TRAVERSE_TYPE(DecayedType, { TRY_TO(TraverseType(T->getOriginalType())); })
1008 
1009 DEF_TRAVERSE_TYPE(ConstantArrayType, {
1010  TRY_TO(TraverseType(T->getElementType()));
1011  if (T->getSizeExpr())
1012  TRY_TO(TraverseStmt(const_cast<Expr*>(T->getSizeExpr())));
1013 })
1014 
1015 DEF_TRAVERSE_TYPE(IncompleteArrayType,
1016  { TRY_TO(TraverseType(T->getElementType())); })
1017 
1018 DEF_TRAVERSE_TYPE(VariableArrayType, {
1019  TRY_TO(TraverseType(T->getElementType()));
1020  TRY_TO(TraverseStmt(T->getSizeExpr()));
1021 })
1022 
1023 DEF_TRAVERSE_TYPE(DependentSizedArrayType, {
1024  TRY_TO(TraverseType(T->getElementType()));
1025  if (T->getSizeExpr())
1026  TRY_TO(TraverseStmt(T->getSizeExpr()));
1027 })
1028 
1029 DEF_TRAVERSE_TYPE(DependentAddressSpaceType, {
1030  TRY_TO(TraverseStmt(T->getAddrSpaceExpr()));
1031  TRY_TO(TraverseType(T->getPointeeType()));
1032 })
1033 
1034 DEF_TRAVERSE_TYPE(DependentVectorType, {
1035  if (T->getSizeExpr())
1036  TRY_TO(TraverseStmt(T->getSizeExpr()));
1037  TRY_TO(TraverseType(T->getElementType()));
1038 })
1039 
1040 DEF_TRAVERSE_TYPE(DependentSizedExtVectorType, {
1041  if (T->getSizeExpr())
1042  TRY_TO(TraverseStmt(T->getSizeExpr()));
1043  TRY_TO(TraverseType(T->getElementType()));
1044 })
1045 
1046 DEF_TRAVERSE_TYPE(VectorType, { TRY_TO(TraverseType(T->getElementType())); })
1047 
1048 DEF_TRAVERSE_TYPE(ExtVectorType, { TRY_TO(TraverseType(T->getElementType())); })
1049 
1050 DEF_TRAVERSE_TYPE(ConstantMatrixType,
1051  { TRY_TO(TraverseType(T->getElementType())); })
1052 
1053 DEF_TRAVERSE_TYPE(DependentSizedMatrixType, {
1054  if (T->getRowExpr())
1055  TRY_TO(TraverseStmt(T->getRowExpr()));
1056  if (T->getColumnExpr())
1057  TRY_TO(TraverseStmt(T->getColumnExpr()));
1058  TRY_TO(TraverseType(T->getElementType()));
1059 })
1060 
1061 DEF_TRAVERSE_TYPE(FunctionNoProtoType,
1062  { TRY_TO(TraverseType(T->getReturnType())); })
1063 
1064 DEF_TRAVERSE_TYPE(FunctionProtoType, {
1065  TRY_TO(TraverseType(T->getReturnType()));
1066 
1067  for (const auto &A : T->param_types()) {
1068  TRY_TO(TraverseType(A));
1069  }
1070 
1071  for (const auto &E : T->exceptions()) {
1072  TRY_TO(TraverseType(E));
1073  }
1074 
1075  if (Expr *NE = T->getNoexceptExpr())
1076  TRY_TO(TraverseStmt(NE));
1077 })
1078 
1079 DEF_TRAVERSE_TYPE(UsingType, {})
1080 DEF_TRAVERSE_TYPE(UnresolvedUsingType, {})
1081 DEF_TRAVERSE_TYPE(TypedefType, {})
1082 
1083 DEF_TRAVERSE_TYPE(TypeOfExprType,
1084  { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
1085 
1086 DEF_TRAVERSE_TYPE(TypeOfType, { TRY_TO(TraverseType(T->getUnderlyingType())); })
1087 
1088 DEF_TRAVERSE_TYPE(DecltypeType,
1089  { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
1090 
1091 DEF_TRAVERSE_TYPE(UnaryTransformType, {
1092  TRY_TO(TraverseType(T->getBaseType()));
1093  TRY_TO(TraverseType(T->getUnderlyingType()));
1094 })
1095 
1096 DEF_TRAVERSE_TYPE(AutoType, {
1097  TRY_TO(TraverseType(T->getDeducedType()));
1098  if (T->isConstrained()) {
1099  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
1100  }
1101 })
1102 DEF_TRAVERSE_TYPE(DeducedTemplateSpecializationType, {
1103  TRY_TO(TraverseTemplateName(T->getTemplateName()));
1104  TRY_TO(TraverseType(T->getDeducedType()));
1105 })
1106 
1107 DEF_TRAVERSE_TYPE(RecordType, {})
1108 DEF_TRAVERSE_TYPE(EnumType, {})
1109 DEF_TRAVERSE_TYPE(TemplateTypeParmType, {})
1110 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType, {
1111  TRY_TO(TraverseType(T->getReplacementType()));
1112 })
1113 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, {
1114  TRY_TO(TraverseTemplateArgument(T->getArgumentPack()));
1115 })
1116 
1117 DEF_TRAVERSE_TYPE(TemplateSpecializationType, {
1118  TRY_TO(TraverseTemplateName(T->getTemplateName()));
1119  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
1120 })
1121 
1122 DEF_TRAVERSE_TYPE(InjectedClassNameType, {})
1123 
1124 DEF_TRAVERSE_TYPE(AttributedType,
1125  { TRY_TO(TraverseType(T->getModifiedType())); })
1126 
1127 DEF_TRAVERSE_TYPE(BTFTagAttributedType,
1128  { TRY_TO(TraverseType(T->getWrappedType())); })
1129 
1130 DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
1131 
1132 DEF_TRAVERSE_TYPE(MacroQualifiedType,
1133  { TRY_TO(TraverseType(T->getUnderlyingType())); })
1134 
1135 DEF_TRAVERSE_TYPE(ElaboratedType, {
1136  if (T->getQualifier()) {
1137  TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
1138  }
1139  TRY_TO(TraverseType(T->getNamedType()));
1140 })
1141 
1142 DEF_TRAVERSE_TYPE(DependentNameType,
1143  { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); })
1144 
1145 DEF_TRAVERSE_TYPE(DependentTemplateSpecializationType, {
1146  TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
1147  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
1148 })
1149 
1150 DEF_TRAVERSE_TYPE(PackExpansionType, { TRY_TO(TraverseType(T->getPattern())); })
1151 
1152 DEF_TRAVERSE_TYPE(ObjCTypeParamType, {})
1153 
1154 DEF_TRAVERSE_TYPE(ObjCInterfaceType, {})
1155 
1156 DEF_TRAVERSE_TYPE(ObjCObjectType, {
1157  // We have to watch out here because an ObjCInterfaceType's base
1158  // type is itself.
1159  if (T->getBaseType().getTypePtr() != T)
1160  TRY_TO(TraverseType(T->getBaseType()));
1161  for (auto typeArg : T->getTypeArgsAsWritten()) {
1162  TRY_TO(TraverseType(typeArg));
1163  }
1164 })
1165 
1166 DEF_TRAVERSE_TYPE(ObjCObjectPointerType,
1167  { TRY_TO(TraverseType(T->getPointeeType())); })
1168 
1169 DEF_TRAVERSE_TYPE(AtomicType, { TRY_TO(TraverseType(T->getValueType())); })
1170 
1171 DEF_TRAVERSE_TYPE(PipeType, { TRY_TO(TraverseType(T->getElementType())); })
1172 
1173 DEF_TRAVERSE_TYPE(BitIntType, {})
1175  { TRY_TO(TraverseStmt(T->getNumBitsExpr())); })
1176 
1177 #undef DEF_TRAVERSE_TYPE
1178 
1179 // ----------------- TypeLoc traversal -----------------
1180 
1181 // This macro makes available a variable TL, the passed-in TypeLoc.
1182 // If requested, it calls WalkUpFrom* for the Type in the given TypeLoc,
1183 // in addition to WalkUpFrom* for the TypeLoc itself, such that existing
1184 // clients that override the WalkUpFrom*Type() and/or Visit*Type() methods
1185 // continue to work.
1186 #define DEF_TRAVERSE_TYPELOC(TYPE, CODE) \
1187  template <typename Derived> \
1188  bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) { \
1189  if (!getDerived().shouldTraversePostOrder()) { \
1190  TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \
1191  if (getDerived().shouldWalkTypesOfTypeLocs()) \
1192  TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \
1193  } \
1194  { CODE; } \
1195  if (getDerived().shouldTraversePostOrder()) { \
1196  TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \
1197  if (getDerived().shouldWalkTypesOfTypeLocs()) \
1198  TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \
1199  } \
1200  return true; \
1201  }
1202 
1203 template <typename Derived>
1204 bool
1205 RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) {
1206  // Move this over to the 'main' typeloc tree. Note that this is a
1207  // move -- we pretend that we were really looking at the unqualified
1208  // typeloc all along -- rather than a recursion, so we don't follow
1209  // the normal CRTP plan of going through
1210  // getDerived().TraverseTypeLoc. If we did, we'd be traversing
1211  // twice for the same type (once as a QualifiedTypeLoc version of
1212  // the type, once as an UnqualifiedTypeLoc version of the type),
1213  // which in effect means we'd call VisitTypeLoc twice with the
1214  // 'same' type. This solves that problem, at the cost of never
1215  // seeing the qualified version of the type (unless the client
1216  // subclasses TraverseQualifiedTypeLoc themselves). It's not a
1217  // perfect solution. A perfect solution probably requires making
1218  // QualifiedTypeLoc a wrapper around TypeLoc -- like QualType is a
1219  // wrapper around Type* -- rather than being its own class in the
1220  // type hierarchy.
1221  return TraverseTypeLoc(TL.getUnqualifiedLoc());
1222 }
1223 
1224 DEF_TRAVERSE_TYPELOC(BuiltinType, {})
1225 
1226 // FIXME: ComplexTypeLoc is unfinished
1227 DEF_TRAVERSE_TYPELOC(ComplexType, {
1228  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1229 })
1230 
1231 DEF_TRAVERSE_TYPELOC(PointerType,
1232  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1233 
1234 DEF_TRAVERSE_TYPELOC(BlockPointerType,
1235  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1236 
1237 DEF_TRAVERSE_TYPELOC(LValueReferenceType,
1238  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1239 
1240 DEF_TRAVERSE_TYPELOC(RValueReferenceType,
1241  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1242 
1243 // We traverse this in the type case as well, but how is it not reached through
1244 // the pointee type?
1245 DEF_TRAVERSE_TYPELOC(MemberPointerType, {
1246  if (auto *TSI = TL.getClassTInfo())
1247  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
1248  else
1249  TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0)));
1250  TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));
1251 })
1252 
1253 DEF_TRAVERSE_TYPELOC(AdjustedType,
1254  { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1255 
1256 DEF_TRAVERSE_TYPELOC(DecayedType,
1257  { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1258 
1259 template <typename Derived>
1260 bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {
1261  // This isn't available for ArrayType, but is for the ArrayTypeLoc.
1262  TRY_TO(TraverseStmt(TL.getSizeExpr()));
1263  return true;
1264 }
1265 
1266 DEF_TRAVERSE_TYPELOC(ConstantArrayType, {
1267  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1268  TRY_TO(TraverseArrayTypeLocHelper(TL));
1269 })
1270 
1271 DEF_TRAVERSE_TYPELOC(IncompleteArrayType, {
1272  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1273  TRY_TO(TraverseArrayTypeLocHelper(TL));
1274 })
1275 
1276 DEF_TRAVERSE_TYPELOC(VariableArrayType, {
1277  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1278  TRY_TO(TraverseArrayTypeLocHelper(TL));
1279 })
1280 
1281 DEF_TRAVERSE_TYPELOC(DependentSizedArrayType, {
1282  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1283  TRY_TO(TraverseArrayTypeLocHelper(TL));
1284 })
1285 
1286 DEF_TRAVERSE_TYPELOC(DependentAddressSpaceType, {
1287  TRY_TO(TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr()));
1288  TRY_TO(TraverseType(TL.getTypePtr()->getPointeeType()));
1289 })
1290 
1291 // FIXME: order? why not size expr first?
1292 // FIXME: base VectorTypeLoc is unfinished
1293 DEF_TRAVERSE_TYPELOC(DependentSizedExtVectorType, {
1294  if (TL.getTypePtr()->getSizeExpr())
1295  TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));
1296  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1297 })
1298 
1299 // FIXME: VectorTypeLoc is unfinished
1300 DEF_TRAVERSE_TYPELOC(VectorType, {
1301  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1302 })
1303 
1304 DEF_TRAVERSE_TYPELOC(DependentVectorType, {
1305  if (TL.getTypePtr()->getSizeExpr())
1306  TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));
1307  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1308 })
1309 
1310 // FIXME: size and attributes
1311 // FIXME: base VectorTypeLoc is unfinished
1312 DEF_TRAVERSE_TYPELOC(ExtVectorType, {
1313  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1314 })
1315 
1316 DEF_TRAVERSE_TYPELOC(ConstantMatrixType, {
1317  TRY_TO(TraverseStmt(TL.getAttrRowOperand()));
1318  TRY_TO(TraverseStmt(TL.getAttrColumnOperand()));
1319  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1320 })
1321 
1322 DEF_TRAVERSE_TYPELOC(DependentSizedMatrixType, {
1323  TRY_TO(TraverseStmt(TL.getAttrRowOperand()));
1324  TRY_TO(TraverseStmt(TL.getAttrColumnOperand()));
1325  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1326 })
1327 
1328 DEF_TRAVERSE_TYPELOC(FunctionNoProtoType,
1329  { TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); })
1330 
1331 // FIXME: location of exception specifications (attributes?)
1332 DEF_TRAVERSE_TYPELOC(FunctionProtoType, {
1333  TRY_TO(TraverseTypeLoc(TL.getReturnLoc()));
1334 
1335  const FunctionProtoType *T = TL.getTypePtr();
1336 
1337  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
1338  if (TL.getParam(I)) {
1339  TRY_TO(TraverseDecl(TL.getParam(I)));
1340  } else if (I < T->getNumParams()) {
1341  TRY_TO(TraverseType(T->getParamType(I)));
1342  }
1343  }
1344 
1345  for (const auto &E : T->exceptions()) {
1346  TRY_TO(TraverseType(E));
1347  }
1348 
1349  if (Expr *NE = T->getNoexceptExpr())
1350  TRY_TO(TraverseStmt(NE));
1351 })
1352 
1353 DEF_TRAVERSE_TYPELOC(UsingType, {})
1354 DEF_TRAVERSE_TYPELOC(UnresolvedUsingType, {})
1355 DEF_TRAVERSE_TYPELOC(TypedefType, {})
1356 
1357 DEF_TRAVERSE_TYPELOC(TypeOfExprType,
1358  { TRY_TO(TraverseStmt(TL.getUnderlyingExpr())); })
1359 
1360 DEF_TRAVERSE_TYPELOC(TypeOfType, {
1361  TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1362 })
1363 
1364 // FIXME: location of underlying expr
1365 DEF_TRAVERSE_TYPELOC(DecltypeType, {
1366  TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr()));
1367 })
1368 
1369 DEF_TRAVERSE_TYPELOC(UnaryTransformType, {
1370  TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1371 })
1372 
1373 DEF_TRAVERSE_TYPELOC(AutoType, {
1374  TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
1375  if (TL.isConstrained()) {
1376  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc()));
1377  TRY_TO(TraverseDeclarationNameInfo(TL.getConceptNameInfo()));
1378  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
1379  TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1380  }
1381 })
1382 
1383 DEF_TRAVERSE_TYPELOC(DeducedTemplateSpecializationType, {
1384  TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));
1385  TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
1386 })
1387 
1388 DEF_TRAVERSE_TYPELOC(RecordType, {})
1389 DEF_TRAVERSE_TYPELOC(EnumType, {})
1390 DEF_TRAVERSE_TYPELOC(TemplateTypeParmType, {})
1391 DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType, {
1392  TRY_TO(TraverseType(TL.getTypePtr()->getReplacementType()));
1393 })
1394 DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmPackType, {
1395  TRY_TO(TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack()));
1396 })
1397 
1398 // FIXME: use the loc for the template name?
1399 DEF_TRAVERSE_TYPELOC(TemplateSpecializationType, {
1400  TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));
1401  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1402  TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1403  }
1404 })
1405 
1406 DEF_TRAVERSE_TYPELOC(InjectedClassNameType, {})
1407 
1408 DEF_TRAVERSE_TYPELOC(ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
1409 
1410 DEF_TRAVERSE_TYPELOC(MacroQualifiedType,
1411  { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
1412 
1413 DEF_TRAVERSE_TYPELOC(AttributedType,
1414  { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); })
1415 
1416 DEF_TRAVERSE_TYPELOC(BTFTagAttributedType,
1417  { TRY_TO(TraverseTypeLoc(TL.getWrappedLoc())); })
1418 
1419 DEF_TRAVERSE_TYPELOC(ElaboratedType, {
1420  if (TL.getQualifierLoc()) {
1421  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1422  }
1423  TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc()));
1424 })
1425 
1426 DEF_TRAVERSE_TYPELOC(DependentNameType, {
1427  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1428 })
1429 
1430 DEF_TRAVERSE_TYPELOC(DependentTemplateSpecializationType, {
1431  if (TL.getQualifierLoc()) {
1432  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1433  }
1434 
1435  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1436  TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1437  }
1438 })
1439 
1440 DEF_TRAVERSE_TYPELOC(PackExpansionType,
1441  { TRY_TO(TraverseTypeLoc(TL.getPatternLoc())); })
1442 
1443 DEF_TRAVERSE_TYPELOC(ObjCTypeParamType, {
1444  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1445  ObjCProtocolLoc ProtocolLoc(TL.getProtocol(I), TL.getProtocolLoc(I));
1446  TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));
1447  }
1448 })
1449 
1450 DEF_TRAVERSE_TYPELOC(ObjCInterfaceType, {})
1451 
1452 DEF_TRAVERSE_TYPELOC(ObjCObjectType, {
1453  // We have to watch out here because an ObjCInterfaceType's base
1454  // type is itself.
1455  if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr())
1456  TRY_TO(TraverseTypeLoc(TL.getBaseLoc()));
1457  for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
1458  TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc()));
1459  for (unsigned I = 0, N = TL.getNumProtocols(); I != N; ++I) {
1460  ObjCProtocolLoc ProtocolLoc(TL.getProtocol(I), TL.getProtocolLoc(I));
1461  TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));
1462  }
1463 })
1464 
1465 DEF_TRAVERSE_TYPELOC(ObjCObjectPointerType,
1466  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1467 
1468 DEF_TRAVERSE_TYPELOC(AtomicType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc())); })
1469 
1470 DEF_TRAVERSE_TYPELOC(PipeType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc())); })
1471 
1472 DEF_TRAVERSE_TYPELOC(BitIntType, {})
1473 DEF_TRAVERSE_TYPELOC(DependentBitIntType, {
1474  TRY_TO(TraverseStmt(TL.getTypePtr()->getNumBitsExpr()));
1475 })
1476 
1477 #undef DEF_TRAVERSE_TYPELOC
1478 
1479 // ----------------- Decl traversal -----------------
1480 //
1481 // For a Decl, we automate (in the DEF_TRAVERSE_DECL macro) traversing
1482 // the children that come from the DeclContext associated with it.
1483 // Therefore each Traverse* only needs to worry about children other
1484 // than those.
1485 
1486 template <typename Derived>
1488  const Decl *Child) {
1489  // BlockDecls are traversed through BlockExprs,
1490  // CapturedDecls are traversed through CapturedStmts.
1491  if (isa<BlockDecl>(Child) || isa<CapturedDecl>(Child))
1492  return true;
1493  // Lambda classes are traversed through LambdaExprs.
1494  if (const CXXRecordDecl* Cls = dyn_cast<CXXRecordDecl>(Child))
1495  return Cls->isLambda();
1496  return false;
1497 }
1498 
1499 template <typename Derived>
1501  if (!DC)
1502  return true;
1503 
1504  for (auto *Child : DC->decls()) {
1505  if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))
1506  TRY_TO(TraverseDecl(Child));
1507  }
1508 
1509  return true;
1510 }
1511 
1512 // This macro makes available a variable D, the passed-in decl.
1513 #define DEF_TRAVERSE_DECL(DECL, CODE) \
1514  template <typename Derived> \
1515  bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) { \
1516  bool ShouldVisitChildren = true; \
1517  bool ReturnValue = true; \
1518  if (!getDerived().shouldTraversePostOrder()) \
1519  TRY_TO(WalkUpFrom##DECL(D)); \
1520  { CODE; } \
1521  if (ReturnValue && ShouldVisitChildren) \
1522  TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D))); \
1523  if (ReturnValue) { \
1524  /* Visit any attributes attached to this declaration. */ \
1525  for (auto *I : D->attrs()) \
1526  TRY_TO(getDerived().TraverseAttr(I)); \
1527  } \
1528  if (ReturnValue && getDerived().shouldTraversePostOrder()) \
1529  TRY_TO(WalkUpFrom##DECL(D)); \
1530  return ReturnValue; \
1531  }
1532 
1533 DEF_TRAVERSE_DECL(AccessSpecDecl, {})
1534 
1535 DEF_TRAVERSE_DECL(BlockDecl, {
1536  if (TypeSourceInfo *TInfo = D->getSignatureAsWritten())
1537  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
1538  TRY_TO(TraverseStmt(D->getBody()));
1539  for (const auto &I : D->captures()) {
1540  if (I.hasCopyExpr()) {
1541  TRY_TO(TraverseStmt(I.getCopyExpr()));
1542  }
1543  }
1544  ShouldVisitChildren = false;
1545 })
1546 
1547 DEF_TRAVERSE_DECL(CapturedDecl, {
1548  TRY_TO(TraverseStmt(D->getBody()));
1550 })
1551 
1552 DEF_TRAVERSE_DECL(EmptyDecl, {})
1553 
1554 DEF_TRAVERSE_DECL(LifetimeExtendedTemporaryDecl, {
1555  TRY_TO(TraverseStmt(D->getTemporaryExpr()));
1556 })
1557 
1558 DEF_TRAVERSE_DECL(FileScopeAsmDecl,
1559  { TRY_TO(TraverseStmt(D->getAsmString())); })
1560 
1561 DEF_TRAVERSE_DECL(ImportDecl, {})
1562 
1563 DEF_TRAVERSE_DECL(FriendDecl, {
1564  // Friend is either decl or a type.
1565  if (D->getFriendType())
1566  TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1567  else
1568  TRY_TO(TraverseDecl(D->getFriendDecl()));
1569 })
1570 
1571 DEF_TRAVERSE_DECL(FriendTemplateDecl, {
1572  if (D->getFriendType())
1573  TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1574  else
1575  TRY_TO(TraverseDecl(D->getFriendDecl()));
1576  for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) {
1577  TemplateParameterList *TPL = D->getTemplateParameterList(I);
1578  for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end();
1579  ITPL != ETPL; ++ITPL) {
1580  TRY_TO(TraverseDecl(*ITPL));
1581  }
1582  }
1583 })
1584 
1585 DEF_TRAVERSE_DECL(ClassScopeFunctionSpecializationDecl, {
1586  TRY_TO(TraverseDecl(D->getSpecialization()));
1587 
1588  if (D->hasExplicitTemplateArgs()) {
1589  TRY_TO(TraverseTemplateArgumentLocsHelper(
1590  D->getTemplateArgsAsWritten()->getTemplateArgs(),
1591  D->getTemplateArgsAsWritten()->NumTemplateArgs));
1592  }
1593 })
1594 
1595 DEF_TRAVERSE_DECL(LinkageSpecDecl, {})
1596 
1597 DEF_TRAVERSE_DECL(ExportDecl, {})
1598 
1599 DEF_TRAVERSE_DECL(ObjCPropertyImplDecl, {// FIXME: implement this
1600  })
1601 
1602 DEF_TRAVERSE_DECL(StaticAssertDecl, {
1603  TRY_TO(TraverseStmt(D->getAssertExpr()));
1604  TRY_TO(TraverseStmt(D->getMessage()));
1605 })
1606 
1607 DEF_TRAVERSE_DECL(TranslationUnitDecl, {
1608  // Code in an unnamed namespace shows up automatically in
1609  // decls_begin()/decls_end(). Thus we don't need to recurse on
1610  // D->getAnonymousNamespace().
1611 
1612  // If the traversal scope is set, then consider them to be the children of
1613  // the TUDecl, rather than traversing (and loading?) all top-level decls.
1614  auto Scope = D->getASTContext().getTraversalScope();
1615  bool HasLimitedScope =
1616  Scope.size() != 1 || !isa<TranslationUnitDecl>(Scope.front());
1617  if (HasLimitedScope) {
1618  ShouldVisitChildren = false; // we'll do that here instead
1619  for (auto *Child : Scope) {
1620  if (!canIgnoreChildDeclWhileTraversingDeclContext(Child))
1621  TRY_TO(TraverseDecl(Child));
1622  }
1623  }
1624 })
1625 
1626 DEF_TRAVERSE_DECL(PragmaCommentDecl, {})
1627 
1628 DEF_TRAVERSE_DECL(PragmaDetectMismatchDecl, {})
1629 
1630 DEF_TRAVERSE_DECL(ExternCContextDecl, {})
1631 
1632 DEF_TRAVERSE_DECL(NamespaceAliasDecl, {
1633  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1634 
1635  // We shouldn't traverse an aliased namespace, since it will be
1636  // defined (and, therefore, traversed) somewhere else.
1637  ShouldVisitChildren = false;
1638 })
1639 
1640 DEF_TRAVERSE_DECL(LabelDecl, {// There is no code in a LabelDecl.
1641  })
1642 
1644  NamespaceDecl,
1645  {// Code in an unnamed namespace shows up automatically in
1646  // decls_begin()/decls_end(). Thus we don't need to recurse on
1647  // D->getAnonymousNamespace().
1648  })
1649 
1650 DEF_TRAVERSE_DECL(ObjCCompatibleAliasDecl, {// FIXME: implement
1651  })
1652 
1653 DEF_TRAVERSE_DECL(ObjCCategoryDecl, {
1654  if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) {
1655  for (auto typeParam : *typeParamList) {
1656  TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1657  }
1658  }
1659  for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {
1660  ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));
1661  TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));
1662  }
1663 })
1664 
1665 DEF_TRAVERSE_DECL(ObjCCategoryImplDecl, {// FIXME: implement
1666  })
1667 
1668 DEF_TRAVERSE_DECL(ObjCImplementationDecl, {// FIXME: implement
1669  })
1670 
1671 DEF_TRAVERSE_DECL(ObjCInterfaceDecl, {
1672  if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) {
1673  for (auto typeParam : *typeParamList) {
1674  TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1675  }
1676  }
1677 
1678  if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) {
1679  TRY_TO(TraverseTypeLoc(superTInfo->getTypeLoc()));
1680  }
1681  if (D->isThisDeclarationADefinition()) {
1682  for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {
1683  ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));
1684  TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));
1685  }
1686  }
1687 })
1688 
1689 DEF_TRAVERSE_DECL(ObjCProtocolDecl, {
1690  if (D->isThisDeclarationADefinition()) {
1691  for (auto It : llvm::zip(D->protocols(), D->protocol_locs())) {
1692  ObjCProtocolLoc ProtocolLoc(std::get<0>(It), std::get<1>(It));
1693  TRY_TO(TraverseObjCProtocolLoc(ProtocolLoc));
1694  }
1695  }
1696 })
1697 
1698 DEF_TRAVERSE_DECL(ObjCMethodDecl, {
1699  if (D->getReturnTypeSourceInfo()) {
1700  TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc()));
1701  }
1702  for (ParmVarDecl *Parameter : D->parameters()) {
1703  TRY_TO(TraverseDecl(Parameter));
1704  }
1705  if (D->isThisDeclarationADefinition()) {
1706  TRY_TO(TraverseStmt(D->getBody()));
1707  }
1708  ShouldVisitChildren = false;
1709 })
1710 
1711 DEF_TRAVERSE_DECL(ObjCTypeParamDecl, {
1712  if (D->hasExplicitBound()) {
1713  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1714  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1715  // declaring the type alias, not something that was written in the
1716  // source.
1717  }
1718 })
1719 
1720 DEF_TRAVERSE_DECL(ObjCPropertyDecl, {
1721  if (D->getTypeSourceInfo())
1722  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1723  else
1724  TRY_TO(TraverseType(D->getType()));
1725  ShouldVisitChildren = false;
1726 })
1727 
1728 DEF_TRAVERSE_DECL(UsingDecl, {
1729  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1730  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1731 })
1732 
1733 DEF_TRAVERSE_DECL(UsingEnumDecl, {})
1734 
1735 DEF_TRAVERSE_DECL(UsingPackDecl, {})
1736 
1737 DEF_TRAVERSE_DECL(UsingDirectiveDecl, {
1738  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1739 })
1740 
1741 DEF_TRAVERSE_DECL(UsingShadowDecl, {})
1742 
1743 DEF_TRAVERSE_DECL(ConstructorUsingShadowDecl, {})
1744 
1745 DEF_TRAVERSE_DECL(OMPThreadPrivateDecl, {
1746  for (auto *I : D->varlists()) {
1747  TRY_TO(TraverseStmt(I));
1748  }
1749  })
1750 
1751 DEF_TRAVERSE_DECL(OMPRequiresDecl, {
1752  for (auto *C : D->clauselists()) {
1753  TRY_TO(TraverseOMPClause(C));
1754  }
1755 })
1756 
1757 DEF_TRAVERSE_DECL(OMPDeclareReductionDecl, {
1758  TRY_TO(TraverseStmt(D->getCombiner()));
1759  if (auto *Initializer = D->getInitializer())
1760  TRY_TO(TraverseStmt(Initializer));
1761  TRY_TO(TraverseType(D->getType()));
1762  return true;
1763 })
1764 
1765 DEF_TRAVERSE_DECL(OMPDeclareMapperDecl, {
1766  for (auto *C : D->clauselists())
1767  TRY_TO(TraverseOMPClause(C));
1768  TRY_TO(TraverseType(D->getType()));
1769  return true;
1770 })
1771 
1772 DEF_TRAVERSE_DECL(OMPCapturedExprDecl, { TRY_TO(TraverseVarHelper(D)); })
1773 
1774 DEF_TRAVERSE_DECL(OMPAllocateDecl, {
1775  for (auto *I : D->varlists())
1776  TRY_TO(TraverseStmt(I));
1777  for (auto *C : D->clauselists())
1778  TRY_TO(TraverseOMPClause(C));
1779 })
1780 
1781 // A helper method for TemplateDecl's children.
1782 template <typename Derived>
1783 bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
1784  TemplateParameterList *TPL) {
1785  if (TPL) {
1786  for (NamedDecl *D : *TPL) {
1787  TRY_TO(TraverseDecl(D));
1788  }
1789  if (Expr *RequiresClause = TPL->getRequiresClause()) {
1790  TRY_TO(TraverseStmt(RequiresClause));
1791  }
1792  }
1793  return true;
1794 }
1795 
1796 template <typename Derived>
1797 template <typename T>
1798 bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) {
1799  for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) {
1800  TemplateParameterList *TPL = D->getTemplateParameterList(i);
1801  TraverseTemplateParameterListHelper(TPL);
1802  }
1803  return true;
1804 }
1805 
1806 template <typename Derived>
1807 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1808  ClassTemplateDecl *D) {
1809  for (auto *SD : D->specializations()) {
1810  for (auto *RD : SD->redecls()) {
1811  assert(!cast<CXXRecordDecl>(RD)->isInjectedClassName());
1812  switch (
1813  cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1814  // Visit the implicit instantiations with the requested pattern.
1815  case TSK_Undeclared:
1817  TRY_TO(TraverseDecl(RD));
1818  break;
1819 
1820  // We don't need to do anything on an explicit instantiation
1821  // or explicit specialization because there will be an explicit
1822  // node for it elsewhere.
1826  break;
1827  }
1828  }
1829  }
1830 
1831  return true;
1832 }
1833 
1834 template <typename Derived>
1835 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1836  VarTemplateDecl *D) {
1837  for (auto *SD : D->specializations()) {
1838  for (auto *RD : SD->redecls()) {
1839  switch (
1840  cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1841  case TSK_Undeclared:
1843  TRY_TO(TraverseDecl(RD));
1844  break;
1845 
1849  break;
1850  }
1851  }
1852  }
1853 
1854  return true;
1855 }
1856 
1857 // A helper method for traversing the instantiations of a
1858 // function while skipping its specializations.
1859 template <typename Derived>
1860 bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations(
1861  FunctionTemplateDecl *D) {
1862  for (auto *FD : D->specializations()) {
1863  for (auto *RD : FD->redecls()) {
1864  switch (RD->getTemplateSpecializationKind()) {
1865  case TSK_Undeclared:
1867  // We don't know what kind of FunctionDecl this is.
1868  TRY_TO(TraverseDecl(RD));
1869  break;
1870 
1871  // FIXME: For now traverse explicit instantiations here. Change that
1872  // once they are represented as dedicated nodes in the AST.
1875  TRY_TO(TraverseDecl(RD));
1876  break;
1877 
1879  break;
1880  }
1881  }
1882  }
1883 
1884  return true;
1885 }
1886 
1887 // This macro unifies the traversal of class, variable and function
1888 // template declarations.
1889 #define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND) \
1890  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, { \
1891  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); \
1892  TRY_TO(TraverseDecl(D->getTemplatedDecl())); \
1893  \
1894  /* By default, we do not traverse the instantiations of \
1895  class templates since they do not appear in the user code. The \
1896  following code optionally traverses them. \
1897  \
1898  We only traverse the class instantiations when we see the canonical \
1899  declaration of the template, to ensure we only visit them once. */ \
1900  if (getDerived().shouldVisitTemplateInstantiations() && \
1901  D == D->getCanonicalDecl()) \
1902  TRY_TO(TraverseTemplateInstantiations(D)); \
1903  \
1904  /* Note that getInstantiatedFromMemberTemplate() is just a link \
1905  from a template instantiation back to the template from which \
1906  it was instantiated, and thus should not be traversed. */ \
1907  })
1908 
1911 DEF_TRAVERSE_TMPL_DECL(Function)
1912 
1913 DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
1914  // D is the "T" in something like
1915  // template <template <typename> class T> class container { };
1916  TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1917  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
1918  TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));
1919  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1920 })
1921 
1922 DEF_TRAVERSE_DECL(BuiltinTemplateDecl, {
1923  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1924 })
1925 
1926 template <typename Derived>
1927 bool RecursiveASTVisitor<Derived>::TraverseTemplateTypeParamDeclConstraints(
1928  const TemplateTypeParmDecl *D) {
1929  if (const auto *TC = D->getTypeConstraint())
1930  TRY_TO(TraverseTypeConstraint(TC));
1931  return true;
1932 }
1933 
1934 DEF_TRAVERSE_DECL(TemplateTypeParmDecl, {
1935  // D is the "T" in something like "template<typename T> class vector;"
1936  if (D->getTypeForDecl())
1937  TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
1938  TRY_TO(TraverseTemplateTypeParamDeclConstraints(D));
1939  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
1940  TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
1941 })
1942 
1943 DEF_TRAVERSE_DECL(TypedefDecl, {
1944  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1945  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1946  // declaring the typedef, not something that was written in the
1947  // source.
1948 })
1949 
1950 DEF_TRAVERSE_DECL(TypeAliasDecl, {
1951  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1952  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1953  // declaring the type alias, not something that was written in the
1954  // source.
1955 })
1956 
1957 DEF_TRAVERSE_DECL(TypeAliasTemplateDecl, {
1958  TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1959  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1960 })
1961 
1962 DEF_TRAVERSE_DECL(ConceptDecl, {
1963  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1964  TRY_TO(TraverseStmt(D->getConstraintExpr()));
1965 })
1966 
1967 DEF_TRAVERSE_DECL(UnresolvedUsingTypenameDecl, {
1968  // A dependent using declaration which was marked with 'typename'.
1969  // template<class T> class A : public B<T> { using typename B<T>::foo; };
1970  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1971  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1972  // declaring the type, not something that was written in the
1973  // source.
1974 })
1975 
1976 DEF_TRAVERSE_DECL(UnresolvedUsingIfExistsDecl, {})
1977 
1978 DEF_TRAVERSE_DECL(EnumDecl, {
1979  TRY_TO(TraverseDeclTemplateParameterLists(D));
1980 
1981  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1982  if (auto *TSI = D->getIntegerTypeSourceInfo())
1983  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
1984  // The enumerators are already traversed by
1985  // decls_begin()/decls_end().
1986 })
1987 
1988 // Helper methods for RecordDecl and its children.
1989 template <typename Derived>
1990 bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
1991  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1992  // declaring the type, not something that was written in the source.
1993 
1994  TRY_TO(TraverseDeclTemplateParameterLists(D));
1995  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1996  return true;
1997 }
1998 
1999 template <typename Derived>
2000 bool RecursiveASTVisitor<Derived>::TraverseCXXBaseSpecifier(
2001  const CXXBaseSpecifier &Base) {
2002  TRY_TO(TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc()));
2003  return true;
2004 }
2005 
2006 template <typename Derived>
2007 bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
2008  if (!TraverseRecordHelper(D))
2009  return false;
2010  if (D->isCompleteDefinition()) {
2011  for (const auto &I : D->bases()) {
2012  TRY_TO(TraverseCXXBaseSpecifier(I));
2013  }
2014  // We don't traverse the friends or the conversions, as they are
2015  // already in decls_begin()/decls_end().
2016  }
2017  return true;
2018 }
2019 
2020 DEF_TRAVERSE_DECL(RecordDecl, { TRY_TO(TraverseRecordHelper(D)); })
2021 
2022 DEF_TRAVERSE_DECL(CXXRecordDecl, { TRY_TO(TraverseCXXRecordHelper(D)); })
2023 
2024 #define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND, DECLKIND) \
2025  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateSpecializationDecl, { \
2026  /* For implicit instantiations ("set<int> x;"), we don't want to \
2027  recurse at all, since the instatiated template isn't written in \
2028  the source code anywhere. (Note the instatiated *type* -- \
2029  set<int> -- is written, and will still get a callback of \
2030  TemplateSpecializationType). For explicit instantiations \
2031  ("template set<int>;"), we do need a callback, since this \
2032  is the only callback that's made for this instantiation. \
2033  We use getTypeAsWritten() to distinguish. */ \
2034  if (TypeSourceInfo *TSI = D->getTypeAsWritten()) \
2035  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc())); \
2036  \
2037  if (getDerived().shouldVisitTemplateInstantiations() || \
2038  D->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) { \
2039  /* Traverse base definition for explicit specializations */ \
2040  TRY_TO(Traverse##DECLKIND##Helper(D)); \
2041  } else { \
2042  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); \
2043  \
2044  /* Returning from here skips traversing the \
2045  declaration context of the *TemplateSpecializationDecl \
2046  (embedded in the DEF_TRAVERSE_DECL() macro) \
2047  which contains the instantiated members of the template. */ \
2048  return true; \
2049  } \
2050  })
2051 
2052 DEF_TRAVERSE_TMPL_SPEC_DECL(Class, CXXRecord)
2054 
2055 template <typename Derived>
2056 bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
2057  const TemplateArgumentLoc *TAL, unsigned Count) {
2058  for (unsigned I = 0; I < Count; ++I) {
2059  TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));
2060  }
2061  return true;
2062 }
2063 
2064 #define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND) \
2065  DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, { \
2066  /* The partial specialization. */ \
2067  if (TemplateParameterList *TPL = D->getTemplateParameters()) { \
2068  for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); \
2069  I != E; ++I) { \
2070  TRY_TO(TraverseDecl(*I)); \
2071  } \
2072  } \
2073  /* The args that remains unspecialized. */ \
2074  TRY_TO(TraverseTemplateArgumentLocsHelper( \
2075  D->getTemplateArgsAsWritten()->getTemplateArgs(), \
2076  D->getTemplateArgsAsWritten()->NumTemplateArgs)); \
2077  \
2078  /* Don't need the *TemplatePartialSpecializationHelper, even \
2079  though that's our parent class -- we already visit all the \
2080  template args here. */ \
2081  TRY_TO(Traverse##DECLKIND##Helper(D)); \
2082  \
2083  /* Instantiations will have been visited with the primary template. */ \
2084  })
2085 
2086 DEF_TRAVERSE_TMPL_PART_SPEC_DECL(Class, CXXRecord)
2088 
2089 DEF_TRAVERSE_DECL(EnumConstantDecl, { TRY_TO(TraverseStmt(D->getInitExpr())); })
2090 
2091 DEF_TRAVERSE_DECL(UnresolvedUsingValueDecl, {
2092  // Like UnresolvedUsingTypenameDecl, but without the 'typename':
2093  // template <class T> Class A : public Base<T> { using Base<T>::foo; };
2094  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
2095  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
2096 })
2097 
2098 DEF_TRAVERSE_DECL(IndirectFieldDecl, {})
2099 
2100 template <typename Derived>
2101 bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
2102  TRY_TO(TraverseDeclTemplateParameterLists(D));
2103  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
2104  if (D->getTypeSourceInfo())
2105  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
2106  else
2107  TRY_TO(TraverseType(D->getType()));
2108  return true;
2109 }
2110 
2111 DEF_TRAVERSE_DECL(DecompositionDecl, {
2112  TRY_TO(TraverseVarHelper(D));
2113  for (auto *Binding : D->bindings()) {
2114  TRY_TO(TraverseDecl(Binding));
2115  }
2116 })
2117 
2118 DEF_TRAVERSE_DECL(BindingDecl, {
2119  if (getDerived().shouldVisitImplicitCode())
2120  TRY_TO(TraverseStmt(D->getBinding()));
2121 })
2122 
2123 DEF_TRAVERSE_DECL(MSPropertyDecl, { TRY_TO(TraverseDeclaratorHelper(D)); })
2124 
2125 DEF_TRAVERSE_DECL(MSGuidDecl, {})
2126 DEF_TRAVERSE_DECL(UnnamedGlobalConstantDecl, {})
2127 
2128 DEF_TRAVERSE_DECL(TemplateParamObjectDecl, {})
2129 
2130 DEF_TRAVERSE_DECL(FieldDecl, {
2131  TRY_TO(TraverseDeclaratorHelper(D));
2132  if (D->isBitField())
2133  TRY_TO(TraverseStmt(D->getBitWidth()));
2134  else if (D->hasInClassInitializer())
2135  TRY_TO(TraverseStmt(D->getInClassInitializer()));
2136 })
2137 
2138 DEF_TRAVERSE_DECL(ObjCAtDefsFieldDecl, {
2139  TRY_TO(TraverseDeclaratorHelper(D));
2140  if (D->isBitField())
2141  TRY_TO(TraverseStmt(D->getBitWidth()));
2142  // FIXME: implement the rest.
2143 })
2144 
2145 DEF_TRAVERSE_DECL(ObjCIvarDecl, {
2146  TRY_TO(TraverseDeclaratorHelper(D));
2147  if (D->isBitField())
2148  TRY_TO(TraverseStmt(D->getBitWidth()));
2149  // FIXME: implement the rest.
2150 })
2151 
2152 template <typename Derived>
2153 bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
2154  TRY_TO(TraverseDeclTemplateParameterLists(D));
2155  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
2156  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
2157 
2158  // If we're an explicit template specialization, iterate over the
2159  // template args that were explicitly specified. If we were doing
2160  // this in typing order, we'd do it between the return type and
2161  // the function args, but both are handled by the FunctionTypeLoc
2162  // above, so we have to choose one side. I've decided to do before.
2163  if (const FunctionTemplateSpecializationInfo *FTSI =
2164  D->getTemplateSpecializationInfo()) {
2165  if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared &&
2166  FTSI->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
2167  // A specialization might not have explicit template arguments if it has
2168  // a templated return type and concrete arguments.
2169  if (const ASTTemplateArgumentListInfo *TALI =
2170  FTSI->TemplateArgumentsAsWritten) {
2171  TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(),
2172  TALI->NumTemplateArgs));
2173  }
2174  }
2175  }
2176 
2177  // Visit the function type itself, which can be either
2178  // FunctionNoProtoType or FunctionProtoType, or a typedef. This
2179  // also covers the return type and the function parameters,
2180  // including exception specifications.
2181  if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) {
2182  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
2183  } else if (getDerived().shouldVisitImplicitCode()) {
2184  // Visit parameter variable declarations of the implicit function
2185  // if the traverser is visiting implicit code. Parameter variable
2186  // declarations do not have valid TypeSourceInfo, so to visit them
2187  // we need to traverse the declarations explicitly.
2188  for (ParmVarDecl *Parameter : D->parameters()) {
2189  TRY_TO(TraverseDecl(Parameter));
2190  }
2191  }
2192 
2193  // Visit the trailing requires clause, if any.
2194  if (Expr *TrailingRequiresClause = D->getTrailingRequiresClause()) {
2195  TRY_TO(TraverseStmt(TrailingRequiresClause));
2196  }
2197 
2198  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
2199  // Constructor initializers.
2200  for (auto *I : Ctor->inits()) {
2201  if (I->isWritten() || getDerived().shouldVisitImplicitCode())
2202  TRY_TO(TraverseConstructorInitializer(I));
2203  }
2204  }
2205 
2206  bool VisitBody =
2207  D->isThisDeclarationADefinition() &&
2208  // Don't visit the function body if the function definition is generated
2209  // by clang.
2210  (!D->isDefaulted() || getDerived().shouldVisitImplicitCode());
2211 
2212  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
2213  if (const CXXRecordDecl *RD = MD->getParent()) {
2214  if (RD->isLambda() &&
2215  declaresSameEntity(RD->getLambdaCallOperator(), MD)) {
2216  VisitBody = VisitBody && getDerived().shouldVisitLambdaBody();
2217  }
2218  }
2219  }
2220 
2221  if (VisitBody) {
2222  TRY_TO(TraverseStmt(D->getBody()));
2223  // Body may contain using declarations whose shadows are parented to the
2224  // FunctionDecl itself.
2225  for (auto *Child : D->decls()) {
2226  if (isa<UsingShadowDecl>(Child))
2227  TRY_TO(TraverseDecl(Child));
2228  }
2229  }
2230  return true;
2231 }
2232 
2233 DEF_TRAVERSE_DECL(FunctionDecl, {
2234  // We skip decls_begin/decls_end, which are already covered by
2235  // TraverseFunctionHelper().
2236  ShouldVisitChildren = false;
2237  ReturnValue = TraverseFunctionHelper(D);
2238 })
2239 
2240 DEF_TRAVERSE_DECL(CXXDeductionGuideDecl, {
2241  // We skip decls_begin/decls_end, which are already covered by
2242  // TraverseFunctionHelper().
2243  ShouldVisitChildren = false;
2244  ReturnValue = TraverseFunctionHelper(D);
2245 })
2246 
2247 DEF_TRAVERSE_DECL(CXXMethodDecl, {
2248  // We skip decls_begin/decls_end, which are already covered by
2249  // TraverseFunctionHelper().
2250  ShouldVisitChildren = false;
2251  ReturnValue = TraverseFunctionHelper(D);
2252 })
2253 
2254 DEF_TRAVERSE_DECL(CXXConstructorDecl, {
2255  // We skip decls_begin/decls_end, which are already covered by
2256  // TraverseFunctionHelper().
2257  ShouldVisitChildren = false;
2258  ReturnValue = TraverseFunctionHelper(D);
2259 })
2260 
2261 // CXXConversionDecl is the declaration of a type conversion operator.
2262 // It's not a cast expression.
2263 DEF_TRAVERSE_DECL(CXXConversionDecl, {
2264  // We skip decls_begin/decls_end, which are already covered by
2265  // TraverseFunctionHelper().
2266  ShouldVisitChildren = false;
2267  ReturnValue = TraverseFunctionHelper(D);
2268 })
2269 
2270 DEF_TRAVERSE_DECL(CXXDestructorDecl, {
2271  // We skip decls_begin/decls_end, which are already covered by
2272  // TraverseFunctionHelper().
2273  ShouldVisitChildren = false;
2274  ReturnValue = TraverseFunctionHelper(D);
2275 })
2276 
2277 template <typename Derived>
2278 bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
2279  TRY_TO(TraverseDeclaratorHelper(D));
2280  // Default params are taken care of when we traverse the ParmVarDecl.
2281  if (!isa<ParmVarDecl>(D) &&
2282  (!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode()))
2283  TRY_TO(TraverseStmt(D->getInit()));
2284  return true;
2285 }
2286 
2287 DEF_TRAVERSE_DECL(VarDecl, { TRY_TO(TraverseVarHelper(D)); })
2288 
2289 DEF_TRAVERSE_DECL(ImplicitParamDecl, { TRY_TO(TraverseVarHelper(D)); })
2290 
2291 DEF_TRAVERSE_DECL(NonTypeTemplateParmDecl, {
2292  // A non-type template parameter, e.g. "S" in template<int S> class Foo ...
2293  TRY_TO(TraverseDeclaratorHelper(D));
2294  if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited())
2295  TRY_TO(TraverseStmt(D->getDefaultArgument()));
2296 })
2297 
2298 DEF_TRAVERSE_DECL(ParmVarDecl, {
2299  TRY_TO(TraverseVarHelper(D));
2300 
2301  if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() &&
2302  !D->hasUnparsedDefaultArg())
2303  TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg()));
2304 
2305  if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() &&
2306  !D->hasUnparsedDefaultArg())
2307  TRY_TO(TraverseStmt(D->getDefaultArg()));
2308 })
2309 
2310 DEF_TRAVERSE_DECL(RequiresExprBodyDecl, {})
2311 
2312 #undef DEF_TRAVERSE_DECL
2313 
2314 // ----------------- Stmt traversal -----------------
2315 //
2316 // For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating
2317 // over the children defined in children() (every stmt defines these,
2318 // though sometimes the range is empty). Each individual Traverse*
2319 // method only needs to worry about children other than those. To see
2320 // what children() does for a given class, see, e.g.,
2321 // http://clang.llvm.org/doxygen/Stmt_8cpp_source.html
2322 
2323 // This macro makes available a variable S, the passed-in stmt.
2324 #define DEF_TRAVERSE_STMT(STMT, CODE) \
2325  template <typename Derived> \
2326  bool RecursiveASTVisitor<Derived>::Traverse##STMT( \
2327  STMT *S, DataRecursionQueue *Queue) { \
2328  bool ShouldVisitChildren = true; \
2329  bool ReturnValue = true; \
2330  if (!getDerived().shouldTraversePostOrder()) \
2331  TRY_TO(WalkUpFrom##STMT(S)); \
2332  { CODE; } \
2333  if (ShouldVisitChildren) { \
2334  for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { \
2335  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt); \
2336  } \
2337  } \
2338  /* Call WalkUpFrom if TRY_TO_TRAVERSE_OR_ENQUEUE_STMT has traversed the \
2339  * children already. If TRY_TO_TRAVERSE_OR_ENQUEUE_STMT only enqueued the \
2340  * children, PostVisitStmt will call WalkUpFrom after we are done visiting \
2341  * children. */ \
2342  if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) { \
2343  TRY_TO(WalkUpFrom##STMT(S)); \
2344  } \
2345  return ReturnValue; \
2346  }
2347 
2348 DEF_TRAVERSE_STMT(GCCAsmStmt, {
2349  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getAsmString());
2350  for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) {
2351  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getInputConstraintLiteral(I));
2352  }
2353  for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) {
2354  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOutputConstraintLiteral(I));
2355  }
2356  for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) {
2357  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getClobberStringLiteral(I));
2358  }
2359  // children() iterates over inputExpr and outputExpr.
2360 })
2361 
2363  MSAsmStmt,
2364  {// FIXME: MS Asm doesn't currently parse Constraints, Clobbers, etc. Once
2365  // added this needs to be implemented.
2366  })
2367 
2368 DEF_TRAVERSE_STMT(CXXCatchStmt, {
2369  TRY_TO(TraverseDecl(S->getExceptionDecl()));
2370  // children() iterates over the handler block.
2371 })
2372 
2373 DEF_TRAVERSE_STMT(DeclStmt, {
2374  for (auto *I : S->decls()) {
2375  TRY_TO(TraverseDecl(I));
2376  }
2377  // Suppress the default iteration over children() by
2378  // returning. Here's why: A DeclStmt looks like 'type var [=
2379  // initializer]'. The decls above already traverse over the
2380  // initializers, so we don't have to do it again (which
2381  // children() would do).
2382  ShouldVisitChildren = false;
2383 })
2384 
2385 // These non-expr stmts (most of them), do not need any action except
2386 // iterating over the children.
2387 DEF_TRAVERSE_STMT(BreakStmt, {})
2388 DEF_TRAVERSE_STMT(CXXTryStmt, {})
2389 DEF_TRAVERSE_STMT(CaseStmt, {})
2390 DEF_TRAVERSE_STMT(CompoundStmt, {})
2391 DEF_TRAVERSE_STMT(ContinueStmt, {})
2392 DEF_TRAVERSE_STMT(DefaultStmt, {})
2393 DEF_TRAVERSE_STMT(DoStmt, {})
2394 DEF_TRAVERSE_STMT(ForStmt, {})
2395 DEF_TRAVERSE_STMT(GotoStmt, {})
2396 DEF_TRAVERSE_STMT(IfStmt, {})
2397 DEF_TRAVERSE_STMT(IndirectGotoStmt, {})
2398 DEF_TRAVERSE_STMT(LabelStmt, {})
2399 DEF_TRAVERSE_STMT(AttributedStmt, {})
2400 DEF_TRAVERSE_STMT(NullStmt, {})
2401 DEF_TRAVERSE_STMT(ObjCAtCatchStmt, {})
2402 DEF_TRAVERSE_STMT(ObjCAtFinallyStmt, {})
2403 DEF_TRAVERSE_STMT(ObjCAtSynchronizedStmt, {})
2404 DEF_TRAVERSE_STMT(ObjCAtThrowStmt, {})
2405 DEF_TRAVERSE_STMT(ObjCAtTryStmt, {})
2406 DEF_TRAVERSE_STMT(ObjCForCollectionStmt, {})
2407 DEF_TRAVERSE_STMT(ObjCAutoreleasePoolStmt, {})
2408 
2409 DEF_TRAVERSE_STMT(CXXForRangeStmt, {
2410  if (!getDerived().shouldVisitImplicitCode()) {
2411  if (S->getInit())
2412  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getInit());
2413  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getLoopVarStmt());
2414  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getRangeInit());
2415  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody());
2416  // Visit everything else only if shouldVisitImplicitCode().
2417  ShouldVisitChildren = false;
2418  }
2419 })
2420 
2421 DEF_TRAVERSE_STMT(MSDependentExistsStmt, {
2422  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2423  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
2424 })
2425 
2426 DEF_TRAVERSE_STMT(ReturnStmt, {})
2427 DEF_TRAVERSE_STMT(SwitchStmt, {})
2428 DEF_TRAVERSE_STMT(WhileStmt, {})
2429 
2430 DEF_TRAVERSE_STMT(ConstantExpr, {})
2431 
2432 DEF_TRAVERSE_STMT(CXXDependentScopeMemberExpr, {
2433  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2434  TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
2435  if (S->hasExplicitTemplateArgs()) {
2436  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2437  S->getNumTemplateArgs()));
2438  }
2439 })
2440 
2441 DEF_TRAVERSE_STMT(DeclRefExpr, {
2442  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2443  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
2444  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2445  S->getNumTemplateArgs()));
2446 })
2447 
2448 DEF_TRAVERSE_STMT(DependentScopeDeclRefExpr, {
2449  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2450  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
2451  if (S->hasExplicitTemplateArgs()) {
2452  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2453  S->getNumTemplateArgs()));
2454  }
2455 })
2456 
2457 DEF_TRAVERSE_STMT(MemberExpr, {
2458  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2459  TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
2460  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2461  S->getNumTemplateArgs()));
2462 })
2463 
2465  ImplicitCastExpr,
2466  {// We don't traverse the cast type, as it's not written in the
2467  // source code.
2468  })
2469 
2470 DEF_TRAVERSE_STMT(CStyleCastExpr, {
2471  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2472 })
2473 
2474 DEF_TRAVERSE_STMT(CXXFunctionalCastExpr, {
2475  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2476 })
2477 
2478 DEF_TRAVERSE_STMT(CXXAddrspaceCastExpr, {
2479  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2480 })
2481 
2482 DEF_TRAVERSE_STMT(CXXConstCastExpr, {
2483  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2484 })
2485 
2486 DEF_TRAVERSE_STMT(CXXDynamicCastExpr, {
2487  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2488 })
2489 
2490 DEF_TRAVERSE_STMT(CXXReinterpretCastExpr, {
2491  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2492 })
2493 
2494 DEF_TRAVERSE_STMT(CXXStaticCastExpr, {
2495  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2496 })
2497 
2498 DEF_TRAVERSE_STMT(BuiltinBitCastExpr, {
2499  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2500 })
2501 
2502 template <typename Derived>
2503 bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
2504  InitListExpr *S, DataRecursionQueue *Queue) {
2505  if (S) {
2506  // Skip this if we traverse postorder. We will visit it later
2507  // in PostVisitStmt.
2508  if (!getDerived().shouldTraversePostOrder())
2509  TRY_TO(WalkUpFromInitListExpr(S));
2510 
2511  // All we need are the default actions. FIXME: use a helper function.
2512  for (Stmt *SubStmt : S->children()) {
2514  }
2515 
2516  if (!Queue && getDerived().shouldTraversePostOrder())
2517  TRY_TO(WalkUpFromInitListExpr(S));
2518  }
2519  return true;
2520 }
2521 
2522 template <typename Derived>
2523 bool RecursiveASTVisitor<Derived>::TraverseObjCProtocolLoc(
2524  ObjCProtocolLoc ProtocolLoc) {
2525  return true;
2526 }
2527 
2528 // If shouldVisitImplicitCode() returns false, this method traverses only the
2529 // syntactic form of InitListExpr.
2530 // If shouldVisitImplicitCode() return true, this method is called once for
2531 // each pair of syntactic and semantic InitListExpr, and it traverses the
2532 // subtrees defined by the two forms. This may cause some of the children to be
2533 // visited twice, if they appear both in the syntactic and the semantic form.
2534 //
2535 // There is no guarantee about which form \p S takes when this method is called.
2536 template <typename Derived>
2537 bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(
2538  InitListExpr *S, DataRecursionQueue *Queue) {
2539  if (S->isSemanticForm() && S->isSyntacticForm()) {
2540  // `S` does not have alternative forms, traverse only once.
2541  TRY_TO(TraverseSynOrSemInitListExpr(S, Queue));
2542  return true;
2543  }
2544  TRY_TO(TraverseSynOrSemInitListExpr(
2545  S->isSemanticForm() ? S->getSyntacticForm() : S, Queue));
2546  if (getDerived().shouldVisitImplicitCode()) {
2547  // Only visit the semantic form if the clients are interested in implicit
2548  // compiler-generated.
2549  TRY_TO(TraverseSynOrSemInitListExpr(
2550  S->isSemanticForm() ? S : S->getSemanticForm(), Queue));
2551  }
2552  return true;
2553 }
2554 
2555 // GenericSelectionExpr is a special case because the types and expressions
2556 // are interleaved. We also need to watch out for null types (default
2557 // generic associations).
2558 DEF_TRAVERSE_STMT(GenericSelectionExpr, {
2559  TRY_TO(TraverseStmt(S->getControllingExpr()));
2560  for (const GenericSelectionExpr::Association Assoc : S->associations()) {
2561  if (TypeSourceInfo *TSI = Assoc.getTypeSourceInfo())
2562  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
2563  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(Assoc.getAssociationExpr());
2564  }
2565  ShouldVisitChildren = false;
2566 })
2567 
2568 // PseudoObjectExpr is a special case because of the weirdness with
2569 // syntactic expressions and opaque values.
2570 DEF_TRAVERSE_STMT(PseudoObjectExpr, {
2571  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSyntacticForm());
2572  for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(),
2573  e = S->semantics_end();
2574  i != e; ++i) {
2575  Expr *sub = *i;
2576  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub))
2577  sub = OVE->getSourceExpr();
2579  }
2580  ShouldVisitChildren = false;
2581 })
2582 
2583 DEF_TRAVERSE_STMT(CXXScalarValueInitExpr, {
2584  // This is called for code like 'return T()' where T is a built-in
2585  // (i.e. non-class) type.
2586  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2587 })
2588 
2589 DEF_TRAVERSE_STMT(CXXNewExpr, {
2590  // The child-iterator will pick up the other arguments.
2591  TRY_TO(TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc()));
2592 })
2593 
2594 DEF_TRAVERSE_STMT(OffsetOfExpr, {
2595  // The child-iterator will pick up the expression representing
2596  // the field.
2597  // FIMXE: for code like offsetof(Foo, a.b.c), should we get
2598  // making a MemberExpr callbacks for Foo.a, Foo.a.b, and Foo.a.b.c?
2599  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2600 })
2601 
2602 DEF_TRAVERSE_STMT(UnaryExprOrTypeTraitExpr, {
2603  // The child-iterator will pick up the arg if it's an expression,
2604  // but not if it's a type.
2605  if (S->isArgumentType())
2606  TRY_TO(TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc()));
2607 })
2608 
2609 DEF_TRAVERSE_STMT(CXXTypeidExpr, {
2610  // The child-iterator will pick up the arg if it's an expression,
2611  // but not if it's a type.
2612  if (S->isTypeOperand())
2613  TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2614 })
2615 
2616 DEF_TRAVERSE_STMT(MSPropertyRefExpr, {
2617  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2618 })
2619 
2620 DEF_TRAVERSE_STMT(MSPropertySubscriptExpr, {})
2621 
2622 DEF_TRAVERSE_STMT(CXXUuidofExpr, {
2623  // The child-iterator will pick up the arg if it's an expression,
2624  // but not if it's a type.
2625  if (S->isTypeOperand())
2626  TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2627 })
2628 
2629 DEF_TRAVERSE_STMT(TypeTraitExpr, {
2630  for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2631  TRY_TO(TraverseTypeLoc(S->getArg(I)->getTypeLoc()));
2632 })
2633 
2634 DEF_TRAVERSE_STMT(ArrayTypeTraitExpr, {
2635  TRY_TO(TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc()));
2636 })
2637 
2638 DEF_TRAVERSE_STMT(ExpressionTraitExpr,
2639  { TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getQueriedExpression()); })
2640 
2641 DEF_TRAVERSE_STMT(VAArgExpr, {
2642  // The child-iterator will pick up the expression argument.
2643  TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc()));
2644 })
2645 
2646 DEF_TRAVERSE_STMT(CXXTemporaryObjectExpr, {
2647  // This is called for code like 'return T()' where T is a class type.
2648  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2649 })
2650 
2651 // Walk only the visible parts of lambda expressions.
2652 DEF_TRAVERSE_STMT(LambdaExpr, {
2653  // Visit the capture list.
2654  for (unsigned I = 0, N = S->capture_size(); I != N; ++I) {
2655  const LambdaCapture *C = S->capture_begin() + I;
2656  if (C->isExplicit() || getDerived().shouldVisitImplicitCode()) {
2657  TRY_TO(TraverseLambdaCapture(S, C, S->capture_init_begin()[I]));
2658  }
2659  }
2660 
2661  if (getDerived().shouldVisitImplicitCode()) {
2662  // The implicit model is simple: everything else is in the lambda class.
2663  TRY_TO(TraverseDecl(S->getLambdaClass()));
2664  } else {
2665  // We need to poke around to find the bits that might be explicitly written.
2666  TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2667  FunctionProtoTypeLoc Proto = TL.getAsAdjusted<FunctionProtoTypeLoc>();
2668 
2669  TRY_TO(TraverseTemplateParameterListHelper(S->getTemplateParameterList()));
2670  if (S->hasExplicitParameters()) {
2671  // Visit parameters.
2672  for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I)
2673  TRY_TO(TraverseDecl(Proto.getParam(I)));
2674  }
2675 
2676  auto *T = Proto.getTypePtr();
2677  for (const auto &E : T->exceptions())
2678  TRY_TO(TraverseType(E));
2679 
2680  if (Expr *NE = T->getNoexceptExpr())
2682 
2683  if (S->hasExplicitResultType())
2684  TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));
2685  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getTrailingRequiresClause());
2686 
2687  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody());
2688  }
2689  ShouldVisitChildren = false;
2690 })
2691 
2692 DEF_TRAVERSE_STMT(CXXUnresolvedConstructExpr, {
2693  // This is called for code like 'T()', where T is a template argument.
2694  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2695 })
2696 
2697 // These expressions all might take explicit template arguments.
2698 // We traverse those if so. FIXME: implement these.
2699 DEF_TRAVERSE_STMT(CXXConstructExpr, {})
2700 DEF_TRAVERSE_STMT(CallExpr, {})
2701 DEF_TRAVERSE_STMT(CXXMemberCallExpr, {})
2702 
2703 // These exprs (most of them), do not need any action except iterating
2704 // over the children.
2705 DEF_TRAVERSE_STMT(AddrLabelExpr, {})
2706 DEF_TRAVERSE_STMT(ArraySubscriptExpr, {})
2707 DEF_TRAVERSE_STMT(MatrixSubscriptExpr, {})
2708 DEF_TRAVERSE_STMT(OMPArraySectionExpr, {})
2709 DEF_TRAVERSE_STMT(OMPArrayShapingExpr, {})
2710 DEF_TRAVERSE_STMT(OMPIteratorExpr, {})
2711 
2712 DEF_TRAVERSE_STMT(BlockExpr, {
2713  TRY_TO(TraverseDecl(S->getBlockDecl()));
2714  return true; // no child statements to loop through.
2715 })
2716 
2717 DEF_TRAVERSE_STMT(ChooseExpr, {})
2718 DEF_TRAVERSE_STMT(CompoundLiteralExpr, {
2719  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2720 })
2721 DEF_TRAVERSE_STMT(CXXBindTemporaryExpr, {})
2722 DEF_TRAVERSE_STMT(CXXBoolLiteralExpr, {})
2723 
2724 DEF_TRAVERSE_STMT(CXXDefaultArgExpr, {
2725  if (getDerived().shouldVisitImplicitCode())
2726  TRY_TO(TraverseStmt(S->getExpr()));
2727 })
2728 
2729 DEF_TRAVERSE_STMT(CXXDefaultInitExpr, {})
2730 DEF_TRAVERSE_STMT(CXXDeleteExpr, {})
2731 DEF_TRAVERSE_STMT(ExprWithCleanups, {})
2732 DEF_TRAVERSE_STMT(CXXInheritedCtorInitExpr, {})
2733 DEF_TRAVERSE_STMT(CXXNullPtrLiteralExpr, {})
2734 DEF_TRAVERSE_STMT(CXXStdInitializerListExpr, {})
2735 
2736 DEF_TRAVERSE_STMT(CXXPseudoDestructorExpr, {
2737  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2738  if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())
2739  TRY_TO(TraverseTypeLoc(ScopeInfo->getTypeLoc()));
2740  if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo())
2741  TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc()));
2742 })
2743 
2744 DEF_TRAVERSE_STMT(CXXThisExpr, {})
2745 DEF_TRAVERSE_STMT(CXXThrowExpr, {})
2746 DEF_TRAVERSE_STMT(UserDefinedLiteral, {})
2747 DEF_TRAVERSE_STMT(DesignatedInitExpr, {})
2748 DEF_TRAVERSE_STMT(DesignatedInitUpdateExpr, {})
2749 DEF_TRAVERSE_STMT(ExtVectorElementExpr, {})
2750 DEF_TRAVERSE_STMT(GNUNullExpr, {})
2751 DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {})
2752 DEF_TRAVERSE_STMT(NoInitExpr, {})
2753 DEF_TRAVERSE_STMT(ArrayInitLoopExpr, {
2754  // FIXME: The source expression of the OVE should be listed as
2755  // a child of the ArrayInitLoopExpr.
2756  if (OpaqueValueExpr *OVE = S->getCommonExpr())
2757  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(OVE->getSourceExpr());
2758 })
2759 DEF_TRAVERSE_STMT(ArrayInitIndexExpr, {})
2760 DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {})
2761 
2762 DEF_TRAVERSE_STMT(ObjCEncodeExpr, {
2763  if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo())
2764  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2765 })
2766 
2767 DEF_TRAVERSE_STMT(ObjCIsaExpr, {})
2768 DEF_TRAVERSE_STMT(ObjCIvarRefExpr, {})
2769 
2770 DEF_TRAVERSE_STMT(ObjCMessageExpr, {
2771  if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo())
2772  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2773 })
2774 
2775 DEF_TRAVERSE_STMT(ObjCPropertyRefExpr, {
2776  if (S->isClassReceiver()) {
2777  ObjCInterfaceDecl *IDecl = S->getClassReceiver();
2778  QualType Type = IDecl->getASTContext().getObjCInterfaceType(IDecl);
2779  ObjCInterfaceLocInfo Data;
2780  Data.NameLoc = S->getReceiverLocation();
2781  Data.NameEndLoc = Data.NameLoc;
2782  TRY_TO(TraverseTypeLoc(TypeLoc(Type, &Data)));
2783  }
2784 })
2785 DEF_TRAVERSE_STMT(ObjCSubscriptRefExpr, {})
2786 DEF_TRAVERSE_STMT(ObjCProtocolExpr, {})
2787 DEF_TRAVERSE_STMT(ObjCSelectorExpr, {})
2788 DEF_TRAVERSE_STMT(ObjCIndirectCopyRestoreExpr, {})
2789 
2790 DEF_TRAVERSE_STMT(ObjCBridgedCastExpr, {
2791  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2792 })
2793 
2794 DEF_TRAVERSE_STMT(ObjCAvailabilityCheckExpr, {})
2795 DEF_TRAVERSE_STMT(ParenExpr, {})
2796 DEF_TRAVERSE_STMT(ParenListExpr, {})
2797 DEF_TRAVERSE_STMT(SYCLUniqueStableNameExpr, {
2798  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2799 })
2800 DEF_TRAVERSE_STMT(PredefinedExpr, {})
2801 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
2802 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
2803 DEF_TRAVERSE_STMT(StmtExpr, {})
2804 DEF_TRAVERSE_STMT(SourceLocExpr, {})
2805 
2806 DEF_TRAVERSE_STMT(UnresolvedLookupExpr, {
2807  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2808  if (S->hasExplicitTemplateArgs()) {
2809  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2810  S->getNumTemplateArgs()));
2811  }
2812 })
2813 
2814 DEF_TRAVERSE_STMT(UnresolvedMemberExpr, {
2815  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2816  if (S->hasExplicitTemplateArgs()) {
2817  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2818  S->getNumTemplateArgs()));
2819  }
2820 })
2821 
2822 DEF_TRAVERSE_STMT(SEHTryStmt, {})
2823 DEF_TRAVERSE_STMT(SEHExceptStmt, {})
2824 DEF_TRAVERSE_STMT(SEHFinallyStmt, {})
2825 DEF_TRAVERSE_STMT(SEHLeaveStmt, {})
2826 DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); })
2827 
2828 DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {})
2829 DEF_TRAVERSE_STMT(CXXRewrittenBinaryOperator, {
2830  if (!getDerived().shouldVisitImplicitCode()) {
2831  CXXRewrittenBinaryOperator::DecomposedForm Decomposed =
2832  S->getDecomposedForm();
2833  TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.LHS)));
2834  TRY_TO(TraverseStmt(const_cast<Expr*>(Decomposed.RHS)));
2835  ShouldVisitChildren = false;
2836  }
2837 })
2838 DEF_TRAVERSE_STMT(OpaqueValueExpr, {})
2839 DEF_TRAVERSE_STMT(TypoExpr, {})
2840 DEF_TRAVERSE_STMT(RecoveryExpr, {})
2841 DEF_TRAVERSE_STMT(CUDAKernelCallExpr, {})
2842 
2843 // These operators (all of them) do not need any action except
2844 // iterating over the children.
2845 DEF_TRAVERSE_STMT(BinaryConditionalOperator, {})
2846 DEF_TRAVERSE_STMT(ConditionalOperator, {})
2847 DEF_TRAVERSE_STMT(UnaryOperator, {})
2848 DEF_TRAVERSE_STMT(BinaryOperator, {})
2849 DEF_TRAVERSE_STMT(CompoundAssignOperator, {})
2850 DEF_TRAVERSE_STMT(CXXNoexceptExpr, {})
2851 DEF_TRAVERSE_STMT(PackExpansionExpr, {})
2852 DEF_TRAVERSE_STMT(SizeOfPackExpr, {})
2853 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {})
2854 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {})
2855 DEF_TRAVERSE_STMT(FunctionParmPackExpr, {})
2856 DEF_TRAVERSE_STMT(CXXFoldExpr, {})
2857 DEF_TRAVERSE_STMT(AtomicExpr, {})
2858 
2859 DEF_TRAVERSE_STMT(MaterializeTemporaryExpr, {
2860  if (S->getLifetimeExtendedTemporaryDecl()) {
2861  TRY_TO(TraverseLifetimeExtendedTemporaryDecl(
2862  S->getLifetimeExtendedTemporaryDecl()));
2863  ShouldVisitChildren = false;
2864  }
2865 })
2866 // For coroutines expressions, traverse either the operand
2867 // as written or the implied calls, depending on what the
2868 // derived class requests.
2869 DEF_TRAVERSE_STMT(CoroutineBodyStmt, {
2870  if (!getDerived().shouldVisitImplicitCode()) {
2871  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody());
2872  ShouldVisitChildren = false;
2873  }
2874 })
2875 DEF_TRAVERSE_STMT(CoreturnStmt, {
2876  if (!getDerived().shouldVisitImplicitCode()) {
2877  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
2878  ShouldVisitChildren = false;
2879  }
2880 })
2881 DEF_TRAVERSE_STMT(CoawaitExpr, {
2882  if (!getDerived().shouldVisitImplicitCode()) {
2883  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
2884  ShouldVisitChildren = false;
2885  }
2886 })
2887 DEF_TRAVERSE_STMT(DependentCoawaitExpr, {
2888  if (!getDerived().shouldVisitImplicitCode()) {
2889  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
2890  ShouldVisitChildren = false;
2891  }
2892 })
2893 DEF_TRAVERSE_STMT(CoyieldExpr, {
2894  if (!getDerived().shouldVisitImplicitCode()) {
2895  TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand());
2896  ShouldVisitChildren = false;
2897  }
2898 })
2899 
2900 DEF_TRAVERSE_STMT(ConceptSpecializationExpr,
2901  { TRY_TO(TraverseConceptReferenceHelper(*S)); })
2902 
2903 DEF_TRAVERSE_STMT(RequiresExpr, {
2904  TRY_TO(TraverseDecl(S->getBody()));
2905  for (ParmVarDecl *Parm : S->getLocalParameters())
2906  TRY_TO(TraverseDecl(Parm));
2907  for (concepts::Requirement *Req : S->getRequirements())
2908  TRY_TO(TraverseConceptRequirement(Req));
2909 })
2910 
2911 // These literals (all of them) do not need any action.
2912 DEF_TRAVERSE_STMT(IntegerLiteral, {})
2913 DEF_TRAVERSE_STMT(FixedPointLiteral, {})
2914 DEF_TRAVERSE_STMT(CharacterLiteral, {})
2915 DEF_TRAVERSE_STMT(FloatingLiteral, {})
2916 DEF_TRAVERSE_STMT(ImaginaryLiteral, {})
2917 DEF_TRAVERSE_STMT(StringLiteral, {})
2918 DEF_TRAVERSE_STMT(ObjCStringLiteral, {})
2919 DEF_TRAVERSE_STMT(ObjCBoxedExpr, {})
2920 DEF_TRAVERSE_STMT(ObjCArrayLiteral, {})
2921 DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, {})
2922 
2923 // Traverse OpenCL: AsType, Convert.
2924 DEF_TRAVERSE_STMT(AsTypeExpr, {})
2925 
2926 // OpenMP directives.
2927 template <typename Derived>
2928 bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
2929  OMPExecutableDirective *S) {
2930  for (auto *C : S->clauses()) {
2931  TRY_TO(TraverseOMPClause(C));
2932  }
2933  return true;
2934 }
2935 
2936 DEF_TRAVERSE_STMT(OMPCanonicalLoop, {
2937  if (!getDerived().shouldVisitImplicitCode()) {
2938  // Visit only the syntactical loop.
2939  TRY_TO(TraverseStmt(S->getLoopStmt()));
2940  ShouldVisitChildren = false;
2941  }
2942 })
2943 
2944 template <typename Derived>
2945 bool
2946 RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) {
2947  return TraverseOMPExecutableDirective(S);
2948 }
2949 
2950 DEF_TRAVERSE_STMT(OMPMetaDirective,
2951  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2952 
2953 DEF_TRAVERSE_STMT(OMPParallelDirective,
2954  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2955 
2956 DEF_TRAVERSE_STMT(OMPSimdDirective,
2957  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2958 
2959 DEF_TRAVERSE_STMT(OMPTileDirective,
2960  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2961 
2962 DEF_TRAVERSE_STMT(OMPUnrollDirective,
2963  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2964 
2965 DEF_TRAVERSE_STMT(OMPForDirective,
2966  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2967 
2968 DEF_TRAVERSE_STMT(OMPForSimdDirective,
2969  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2970 
2971 DEF_TRAVERSE_STMT(OMPSectionsDirective,
2972  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2973 
2974 DEF_TRAVERSE_STMT(OMPSectionDirective,
2975  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2976 
2977 DEF_TRAVERSE_STMT(OMPSingleDirective,
2978  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2979 
2980 DEF_TRAVERSE_STMT(OMPMasterDirective,
2981  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2982 
2983 DEF_TRAVERSE_STMT(OMPCriticalDirective, {
2984  TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName()));
2985  TRY_TO(TraverseOMPExecutableDirective(S));
2986 })
2987 
2988 DEF_TRAVERSE_STMT(OMPParallelForDirective,
2989  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2990 
2991 DEF_TRAVERSE_STMT(OMPParallelForSimdDirective,
2992  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2993 
2994 DEF_TRAVERSE_STMT(OMPParallelMasterDirective,
2995  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2996 
2997 DEF_TRAVERSE_STMT(OMPParallelMaskedDirective,
2998  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2999 
3000 DEF_TRAVERSE_STMT(OMPParallelSectionsDirective,
3001  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3002 
3003 DEF_TRAVERSE_STMT(OMPTaskDirective,
3004  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3005 
3006 DEF_TRAVERSE_STMT(OMPTaskyieldDirective,
3007  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3008 
3009 DEF_TRAVERSE_STMT(OMPBarrierDirective,
3010  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3011 
3012 DEF_TRAVERSE_STMT(OMPTaskwaitDirective,
3013  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3014 
3015 DEF_TRAVERSE_STMT(OMPTaskgroupDirective,
3016  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3017 
3018 DEF_TRAVERSE_STMT(OMPCancellationPointDirective,
3019  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3020 
3021 DEF_TRAVERSE_STMT(OMPCancelDirective,
3022  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3023 
3024 DEF_TRAVERSE_STMT(OMPFlushDirective,
3025  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3026 
3027 DEF_TRAVERSE_STMT(OMPDepobjDirective,
3028  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3029 
3030 DEF_TRAVERSE_STMT(OMPScanDirective,
3031  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3032 
3033 DEF_TRAVERSE_STMT(OMPOrderedDirective,
3034  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3035 
3036 DEF_TRAVERSE_STMT(OMPAtomicDirective,
3037  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3038 
3039 DEF_TRAVERSE_STMT(OMPTargetDirective,
3040  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3041 
3042 DEF_TRAVERSE_STMT(OMPTargetDataDirective,
3043  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3044 
3045 DEF_TRAVERSE_STMT(OMPTargetEnterDataDirective,
3046  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3047 
3048 DEF_TRAVERSE_STMT(OMPTargetExitDataDirective,
3049  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3050 
3051 DEF_TRAVERSE_STMT(OMPTargetParallelDirective,
3052  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3053 
3054 DEF_TRAVERSE_STMT(OMPTargetParallelForDirective,
3055  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3056 
3057 DEF_TRAVERSE_STMT(OMPTeamsDirective,
3058  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3059 
3060 DEF_TRAVERSE_STMT(OMPTargetUpdateDirective,
3061  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3062 
3063 DEF_TRAVERSE_STMT(OMPTaskLoopDirective,
3064  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3065 
3066 DEF_TRAVERSE_STMT(OMPTaskLoopSimdDirective,
3067  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3068 
3069 DEF_TRAVERSE_STMT(OMPMasterTaskLoopDirective,
3070  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3071 
3072 DEF_TRAVERSE_STMT(OMPMasterTaskLoopSimdDirective,
3073  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3074 
3075 DEF_TRAVERSE_STMT(OMPParallelMasterTaskLoopDirective,
3076  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3077 
3078 DEF_TRAVERSE_STMT(OMPParallelMasterTaskLoopSimdDirective,
3079  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3080 
3081 DEF_TRAVERSE_STMT(OMPMaskedTaskLoopDirective,
3082  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3083 
3084 DEF_TRAVERSE_STMT(OMPMaskedTaskLoopSimdDirective,
3085  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3086 
3087 DEF_TRAVERSE_STMT(OMPParallelMaskedTaskLoopDirective,
3088  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3089 
3090 DEF_TRAVERSE_STMT(OMPParallelMaskedTaskLoopSimdDirective,
3091  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3092 
3093 DEF_TRAVERSE_STMT(OMPDistributeDirective,
3094  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3095 
3096 DEF_TRAVERSE_STMT(OMPDistributeParallelForDirective,
3097  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3098 
3099 DEF_TRAVERSE_STMT(OMPDistributeParallelForSimdDirective,
3100  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3101 
3102 DEF_TRAVERSE_STMT(OMPDistributeSimdDirective,
3103  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3104 
3105 DEF_TRAVERSE_STMT(OMPTargetParallelForSimdDirective,
3106  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3107 
3108 DEF_TRAVERSE_STMT(OMPTargetSimdDirective,
3109  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3110 
3111 DEF_TRAVERSE_STMT(OMPTeamsDistributeDirective,
3112  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3113 
3114 DEF_TRAVERSE_STMT(OMPTeamsDistributeSimdDirective,
3115  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3116 
3117 DEF_TRAVERSE_STMT(OMPTeamsDistributeParallelForSimdDirective,
3118  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3119 
3120 DEF_TRAVERSE_STMT(OMPTeamsDistributeParallelForDirective,
3121  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3122 
3123 DEF_TRAVERSE_STMT(OMPTargetTeamsDirective,
3124  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3125 
3126 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeDirective,
3127  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3128 
3129 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForDirective,
3130  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3131 
3132 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForSimdDirective,
3133  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3134 
3135 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective,
3136  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3137 
3138 DEF_TRAVERSE_STMT(OMPInteropDirective,
3139  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3140 
3141 DEF_TRAVERSE_STMT(OMPDispatchDirective,
3142  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3143 
3144 DEF_TRAVERSE_STMT(OMPMaskedDirective,
3145  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3146 
3147 DEF_TRAVERSE_STMT(OMPGenericLoopDirective,
3148  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3149 
3150 DEF_TRAVERSE_STMT(OMPTeamsGenericLoopDirective,
3151  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3152 
3153 DEF_TRAVERSE_STMT(OMPTargetTeamsGenericLoopDirective,
3154  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3155 
3156 DEF_TRAVERSE_STMT(OMPParallelGenericLoopDirective,
3157  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3158 
3159 DEF_TRAVERSE_STMT(OMPTargetParallelGenericLoopDirective,
3160  { TRY_TO(TraverseOMPExecutableDirective(S)); })
3161 // OpenMP clauses.
3162 template <typename Derived>
3163 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
3164  if (!C)
3165  return true;
3166  switch (C->getClauseKind()) {
3167 #define GEN_CLANG_CLAUSE_CLASS
3168 #define CLAUSE_CLASS(Enum, Str, Class) \
3169  case llvm::omp::Clause::Enum: \
3170  TRY_TO(Visit##Class(static_cast<Class *>(C))); \
3171  break;
3172 #define CLAUSE_NO_CLASS(Enum, Str) \
3173  case llvm::omp::Clause::Enum: \
3174  break;
3175 #include "llvm/Frontend/OpenMP/OMP.inc"
3176  }
3177  return true;
3178 }
3179 
3180 template <typename Derived>
3181 bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPreInit(
3182  OMPClauseWithPreInit *Node) {
3183  TRY_TO(TraverseStmt(Node->getPreInitStmt()));
3184  return true;
3185 }
3186 
3187 template <typename Derived>
3188 bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPostUpdate(
3189  OMPClauseWithPostUpdate *Node) {
3190  TRY_TO(VisitOMPClauseWithPreInit(Node));
3191  TRY_TO(TraverseStmt(Node->getPostUpdateExpr()));
3192  return true;
3193 }
3194 
3195 template <typename Derived>
3196 bool RecursiveASTVisitor<Derived>::VisitOMPAllocatorClause(
3197  OMPAllocatorClause *C) {
3198  TRY_TO(TraverseStmt(C->getAllocator()));
3199  return true;
3200 }
3201 
3202 template <typename Derived>
3203 bool RecursiveASTVisitor<Derived>::VisitOMPAllocateClause(OMPAllocateClause *C) {
3204  TRY_TO(TraverseStmt(C->getAllocator()));
3205  TRY_TO(VisitOMPClauseList(C));
3206  return true;
3207 }
3208 
3209 template <typename Derived>
3210 bool RecursiveASTVisitor<Derived>::VisitOMPIfClause(OMPIfClause *C) {
3211  TRY_TO(VisitOMPClauseWithPreInit(C));
3212  TRY_TO(TraverseStmt(C->getCondition()));
3213  return true;
3214 }
3215 
3216 template <typename Derived>
3217 bool RecursiveASTVisitor<Derived>::VisitOMPFinalClause(OMPFinalClause *C) {
3218  TRY_TO(VisitOMPClauseWithPreInit(C));
3219  TRY_TO(TraverseStmt(C->getCondition()));
3220  return true;
3221 }
3222 
3223 template <typename Derived>
3224 bool
3225 RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
3226  TRY_TO(VisitOMPClauseWithPreInit(C));
3227  TRY_TO(TraverseStmt(C->getNumThreads()));
3228  return true;
3229 }
3230 
3231 template <typename Derived>
3232 bool RecursiveASTVisitor<Derived>::VisitOMPAlignClause(OMPAlignClause *C) {
3233  TRY_TO(TraverseStmt(C->getAlignment()));
3234  return true;
3235 }
3236 
3237 template <typename Derived>
3238 bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) {
3239  TRY_TO(TraverseStmt(C->getSafelen()));
3240  return true;
3241 }
3242 
3243 template <typename Derived>
3244 bool RecursiveASTVisitor<Derived>::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
3245  TRY_TO(TraverseStmt(C->getSimdlen()));
3246  return true;
3247 }
3248 
3249 template <typename Derived>
3250 bool RecursiveASTVisitor<Derived>::VisitOMPSizesClause(OMPSizesClause *C) {
3251  for (Expr *E : C->getSizesRefs())
3252  TRY_TO(TraverseStmt(E));
3253  return true;
3254 }
3255 
3256 template <typename Derived>
3257 bool RecursiveASTVisitor<Derived>::VisitOMPFullClause(OMPFullClause *C) {
3258  return true;
3259 }
3260 
3261 template <typename Derived>
3262 bool RecursiveASTVisitor<Derived>::VisitOMPPartialClause(OMPPartialClause *C) {
3263  TRY_TO(TraverseStmt(C->getFactor()));
3264  return true;
3265 }
3266 
3267 template <typename Derived>
3268 bool
3269 RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) {
3270  TRY_TO(TraverseStmt(C->getNumForLoops()));
3271  return true;
3272 }
3273 
3274 template <typename Derived>
3275 bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) {
3276  return true;
3277 }
3278 
3279 template <typename Derived>
3280 bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) {
3281  return true;
3282 }
3283 
3284 template <typename Derived>
3285 bool RecursiveASTVisitor<Derived>::VisitOMPUnifiedAddressClause(
3286  OMPUnifiedAddressClause *) {
3287  return true;
3288 }
3289 
3290 template <typename Derived>
3291 bool RecursiveASTVisitor<Derived>::VisitOMPUnifiedSharedMemoryClause(
3292  OMPUnifiedSharedMemoryClause *) {
3293  return true;
3294 }
3295 
3296 template <typename Derived>
3297 bool RecursiveASTVisitor<Derived>::VisitOMPReverseOffloadClause(
3298  OMPReverseOffloadClause *) {
3299  return true;
3300 }
3301 
3302 template <typename Derived>
3303 bool RecursiveASTVisitor<Derived>::VisitOMPDynamicAllocatorsClause(
3304  OMPDynamicAllocatorsClause *) {
3305  return true;
3306 }
3307 
3308 template <typename Derived>
3309 bool RecursiveASTVisitor<Derived>::VisitOMPAtomicDefaultMemOrderClause(
3310  OMPAtomicDefaultMemOrderClause *) {
3311  return true;
3312 }
3313 
3314 template <typename Derived>
3315 bool
3316 RecursiveASTVisitor<Derived>::VisitOMPScheduleClause(OMPScheduleClause *C) {
3317  TRY_TO(VisitOMPClauseWithPreInit(C));
3318  TRY_TO(TraverseStmt(C->getChunkSize()));
3319  return true;
3320 }
3321 
3322 template <typename Derived>
3323 bool RecursiveASTVisitor<Derived>::VisitOMPOrderedClause(OMPOrderedClause *C) {
3324  TRY_TO(TraverseStmt(C->getNumForLoops()));
3325  return true;
3326 }
3327 
3328 template <typename Derived>
3329 bool RecursiveASTVisitor<Derived>::VisitOMPNowaitClause(OMPNowaitClause *) {
3330  return true;
3331 }
3332 
3333 template <typename Derived>
3334 bool RecursiveASTVisitor<Derived>::VisitOMPUntiedClause(OMPUntiedClause *) {
3335  return true;
3336 }
3337 
3338 template <typename Derived>
3339 bool
3340 RecursiveASTVisitor<Derived>::VisitOMPMergeableClause(OMPMergeableClause *) {
3341  return true;
3342 }
3343 
3344 template <typename Derived>
3345 bool RecursiveASTVisitor<Derived>::VisitOMPReadClause(OMPReadClause *) {
3346  return true;
3347 }
3348 
3349 template <typename Derived>
3350 bool RecursiveASTVisitor<Derived>::VisitOMPWriteClause(OMPWriteClause *) {
3351  return true;
3352 }
3353 
3354 template <typename Derived>
3355 bool RecursiveASTVisitor<Derived>::VisitOMPUpdateClause(OMPUpdateClause *) {
3356  return true;
3357 }
3358 
3359 template <typename Derived>
3360 bool RecursiveASTVisitor<Derived>::VisitOMPCaptureClause(OMPCaptureClause *) {
3361  return true;
3362 }
3363 
3364 template <typename Derived>
3365 bool RecursiveASTVisitor<Derived>::VisitOMPCompareClause(OMPCompareClause *) {
3366  return true;
3367 }
3368 
3369 template <typename Derived>
3370 bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
3371  return true;
3372 }
3373 
3374 template <typename Derived>
3375 bool RecursiveASTVisitor<Derived>::VisitOMPAcqRelClause(OMPAcqRelClause *) {
3376  return true;
3377 }
3378 
3379 template <typename Derived>
3380 bool RecursiveASTVisitor<Derived>::VisitOMPAcquireClause(OMPAcquireClause *) {
3381  return true;
3382 }
3383 
3384 template <typename Derived>
3385 bool RecursiveASTVisitor<Derived>::VisitOMPReleaseClause(OMPReleaseClause *) {
3386  return true;
3387 }
3388 
3389 template <typename Derived>
3390 bool RecursiveASTVisitor<Derived>::VisitOMPRelaxedClause(OMPRelaxedClause *) {
3391  return true;
3392 }
3393 
3394 template <typename Derived>
3395 bool RecursiveASTVisitor<Derived>::VisitOMPThreadsClause(OMPThreadsClause *) {
3396  return true;
3397 }
3398 
3399 template <typename Derived>
3400 bool RecursiveASTVisitor<Derived>::VisitOMPSIMDClause(OMPSIMDClause *) {
3401  return true;
3402 }
3403 
3404 template <typename Derived>
3405 bool RecursiveASTVisitor<Derived>::VisitOMPNogroupClause(OMPNogroupClause *) {
3406  return true;
3407 }
3408 
3409 template <typename Derived>
3410 bool RecursiveASTVisitor<Derived>::VisitOMPInitClause(OMPInitClause *C) {
3411  TRY_TO(VisitOMPClauseList(C));
3412  return true;
3413 }
3414 
3415 template <typename Derived>
3416 bool RecursiveASTVisitor<Derived>::VisitOMPUseClause(OMPUseClause *C) {
3417  TRY_TO(TraverseStmt(C->getInteropVar()));
3418  return true;
3419 }
3420 
3421 template <typename Derived>
3422 bool RecursiveASTVisitor<Derived>::VisitOMPDestroyClause(OMPDestroyClause *C) {
3423  TRY_TO(TraverseStmt(C->getInteropVar()));
3424  return true;
3425 }
3426 
3427 template <typename Derived>
3428 bool RecursiveASTVisitor<Derived>::VisitOMPNovariantsClause(
3429  OMPNovariantsClause *C) {
3430  TRY_TO(VisitOMPClauseWithPreInit(C));
3431  TRY_TO(TraverseStmt(C->getCondition()));
3432  return true;
3433 }
3434 
3435 template <typename Derived>
3436 bool RecursiveASTVisitor<Derived>::VisitOMPNocontextClause(
3437  OMPNocontextClause *C) {
3438  TRY_TO(VisitOMPClauseWithPreInit(C));
3439  TRY_TO(TraverseStmt(C->getCondition()));
3440  return true;
3441 }
3442 
3443 template <typename Derived>
3444 template <typename T>
3445 bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
3446  for (auto *E : Node->varlists()) {
3447  TRY_TO(TraverseStmt(E));
3448  }
3449  return true;
3450 }
3451 
3452 template <typename Derived>
3453 bool RecursiveASTVisitor<Derived>::VisitOMPInclusiveClause(
3454  OMPInclusiveClause *C) {
3455  TRY_TO(VisitOMPClauseList(C));
3456  return true;
3457 }
3458 
3459 template <typename Derived>
3460 bool RecursiveASTVisitor<Derived>::VisitOMPExclusiveClause(
3461  OMPExclusiveClause *C) {
3462  TRY_TO(VisitOMPClauseList(C));
3463  return true;
3464 }
3465 
3466 template <typename Derived>
3467 bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
3468  TRY_TO(VisitOMPClauseList(C));
3469  for (auto *E : C->private_copies()) {
3470  TRY_TO(TraverseStmt(E));
3471  }
3472  return true;
3473 }
3474 
3475 template <typename Derived>
3476 bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
3477  OMPFirstprivateClause *C) {
3478  TRY_TO(VisitOMPClauseList(C));
3479  TRY_TO(VisitOMPClauseWithPreInit(C));
3480  for (auto *E : C->private_copies()) {
3481  TRY_TO(TraverseStmt(E));
3482  }
3483  for (auto *E : C->inits()) {
3484  TRY_TO(TraverseStmt(E));
3485  }
3486  return true;
3487 }
3488 
3489 template <typename Derived>
3490 bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
3491  OMPLastprivateClause *C) {
3492  TRY_TO(VisitOMPClauseList(C));
3493  TRY_TO(VisitOMPClauseWithPostUpdate(C));
3494  for (auto *E : C->private_copies()) {
3495  TRY_TO(TraverseStmt(E));
3496  }
3497  for (auto *E : C->source_exprs()) {
3498  TRY_TO(TraverseStmt(E));
3499  }
3500  for (auto *E : C->destination_exprs()) {
3501  TRY_TO(TraverseStmt(E));
3502  }
3503  for (auto *E : C->assignment_ops()) {
3504  TRY_TO(TraverseStmt(E));
3505  }
3506  return true;
3507 }
3508 
3509 template <typename Derived>
3510 bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
3511  TRY_TO(VisitOMPClauseList(C));
3512  return true;
3513 }
3514 
3515 template <typename Derived>
3516 bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(OMPLinearClause *C) {
3517  TRY_TO(TraverseStmt(C->getStep()));
3518  TRY_TO(TraverseStmt(C->getCalcStep()));
3519  TRY_TO(VisitOMPClauseList(C));
3520  TRY_TO(VisitOMPClauseWithPostUpdate(C));
3521  for (auto *E : C->privates()) {
3522  TRY_TO(TraverseStmt(E));
3523  }
3524  for (auto *E : C->inits()) {
3525  TRY_TO(TraverseStmt(E));
3526  }
3527  for (auto *E : C->updates()) {
3528  TRY_TO(TraverseStmt(E));
3529  }
3530  for (auto *E : C->finals()) {
3531  TRY_TO(TraverseStmt(E));
3532  }
3533  return true;
3534 }
3535 
3536 template <typename Derived>
3537 bool RecursiveASTVisitor<Derived>::VisitOMPAlignedClause(OMPAlignedClause *C) {
3538  TRY_TO(TraverseStmt(C->getAlignment()));
3539  TRY_TO(VisitOMPClauseList(C));
3540  return true;
3541 }
3542 
3543 template <typename Derived>
3544 bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(OMPCopyinClause *C) {
3545  TRY_TO(VisitOMPClauseList(C));
3546  for (auto *E : C->source_exprs()) {
3547  TRY_TO(TraverseStmt(E));
3548  }
3549  for (auto *E : C->destination_exprs()) {
3550  TRY_TO(TraverseStmt(E));
3551  }
3552  for (auto *E : C->assignment_ops()) {
3553  TRY_TO(TraverseStmt(E));
3554  }
3555  return true;
3556 }
3557 
3558 template <typename Derived>
3559 bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause(
3560  OMPCopyprivateClause *C) {
3561  TRY_TO(VisitOMPClauseList(C));
3562  for (auto *E : C->source_exprs()) {
3563  TRY_TO(TraverseStmt(E));
3564  }
3565  for (auto *E : C->destination_exprs()) {
3566  TRY_TO(TraverseStmt(E));
3567  }
3568  for (auto *E : C->assignment_ops()) {
3569  TRY_TO(TraverseStmt(E));
3570  }
3571  return true;
3572 }
3573 
3574 template <typename Derived>
3575 bool
3576 RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) {
3577  TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
3578  TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
3579  TRY_TO(VisitOMPClauseList(C));
3580  TRY_TO(VisitOMPClauseWithPostUpdate(C));
3581  for (auto *E : C->privates()) {
3582  TRY_TO(TraverseStmt(E));
3583  }
3584  for (auto *E : C->lhs_exprs()) {
3585  TRY_TO(TraverseStmt(E));
3586  }
3587  for (auto *E : C->rhs_exprs()) {
3588  TRY_TO(TraverseStmt(E));
3589  }
3590  for (auto *E : C->reduction_ops()) {
3591  TRY_TO(TraverseStmt(E));
3592  }
3593  if (C->getModifier() == OMPC_REDUCTION_inscan) {
3594  for (auto *E : C->copy_ops()) {
3595  TRY_TO(TraverseStmt(E));
3596  }
3597  for (auto *E : C->copy_array_temps()) {
3598  TRY_TO(TraverseStmt(E));
3599  }
3600  for (auto *E : C->copy_array_elems()) {
3601  TRY_TO(TraverseStmt(E));
3602  }
3603  }
3604  return true;
3605 }
3606 
3607 template <typename Derived>
3608 bool RecursiveASTVisitor<Derived>::VisitOMPTaskReductionClause(
3609  OMPTaskReductionClause *C) {
3610  TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
3611  TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
3612  TRY_TO(VisitOMPClauseList(C));
3613  TRY_TO(VisitOMPClauseWithPostUpdate(C));
3614  for (auto *E : C->privates()) {
3615  TRY_TO(TraverseStmt(E));
3616  }
3617  for (auto *E : C->lhs_exprs()) {
3618  TRY_TO(TraverseStmt(E));
3619  }
3620  for (auto *E : C->rhs_exprs()) {
3621  TRY_TO(TraverseStmt(E));
3622  }
3623  for (auto *E : C->reduction_ops()) {
3624  TRY_TO(TraverseStmt(E));
3625  }
3626  return true;
3627 }
3628 
3629 template <typename Derived>
3630 bool RecursiveASTVisitor<Derived>::VisitOMPInReductionClause(
3631  OMPInReductionClause *C) {
3632  TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
3633  TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
3634  TRY_TO(VisitOMPClauseList(C));
3635  TRY_TO(VisitOMPClauseWithPostUpdate(C));
3636  for (auto *E : C->privates()) {
3637  TRY_TO(TraverseStmt(E));
3638  }
3639  for (auto *E : C->lhs_exprs()) {
3640  TRY_TO(TraverseStmt(E));
3641  }
3642  for (auto *E : C->rhs_exprs()) {
3643  TRY_TO(TraverseStmt(E));
3644  }
3645  for (auto *E : C->reduction_ops()) {
3646  TRY_TO(TraverseStmt(E));
3647  }
3648  for (auto *E : C->taskgroup_descriptors())
3649  TRY_TO(TraverseStmt(E));
3650  return true;
3651 }
3652 
3653 template <typename Derived>
3654 bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) {
3655  TRY_TO(VisitOMPClauseList(C));
3656  return true;
3657 }
3658 
3659 template <typename Derived>
3660 bool RecursiveASTVisitor<Derived>::VisitOMPDepobjClause(OMPDepobjClause *C) {
3661  TRY_TO(TraverseStmt(C->getDepobj()));
3662  return true;
3663 }
3664 
3665 template <typename Derived>
3666 bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) {
3667  TRY_TO(VisitOMPClauseList(C));
3668  return true;
3669 }
3670 
3671 template <typename Derived>
3672 bool RecursiveASTVisitor<Derived>::VisitOMPDeviceClause(OMPDeviceClause *C) {
3673  TRY_TO(VisitOMPClauseWithPreInit(C));
3674  TRY_TO(TraverseStmt(C->getDevice()));
3675  return true;
3676 }
3677 
3678 template <typename Derived>
3679 bool RecursiveASTVisitor<Derived>::VisitOMPMapClause(OMPMapClause *C) {
3680  TRY_TO(VisitOMPClauseList(C));
3681  return true;
3682 }
3683 
3684 template <typename Derived>
3685 bool RecursiveASTVisitor<Derived>::VisitOMPNumTeamsClause(
3686  OMPNumTeamsClause *C) {
3687  TRY_TO(VisitOMPClauseWithPreInit(C));
3688  TRY_TO(TraverseStmt(C->getNumTeams()));
3689  return true;
3690 }
3691 
3692 template <typename Derived>
3693 bool RecursiveASTVisitor<Derived>::VisitOMPThreadLimitClause(
3694  OMPThreadLimitClause *C) {
3695  TRY_TO(VisitOMPClauseWithPreInit(C));
3696  TRY_TO(TraverseStmt(C->getThreadLimit()));
3697  return true;
3698 }
3699 
3700 template <typename Derived>
3701 bool RecursiveASTVisitor<Derived>::VisitOMPPriorityClause(
3702  OMPPriorityClause *C) {
3703  TRY_TO(VisitOMPClauseWithPreInit(C));
3704  TRY_TO(TraverseStmt(C->getPriority()));
3705  return true;
3706 }
3707 
3708 template <typename Derived>
3709 bool RecursiveASTVisitor<Derived>::VisitOMPGrainsizeClause(
3710  OMPGrainsizeClause *C) {
3711  TRY_TO(VisitOMPClauseWithPreInit(C));
3712  TRY_TO(TraverseStmt(C->getGrainsize()));
3713  return true;
3714 }
3715 
3716 template <typename Derived>
3717 bool RecursiveASTVisitor<Derived>::VisitOMPNumTasksClause(
3718  OMPNumTasksClause *C) {
3719  TRY_TO(VisitOMPClauseWithPreInit(C));
3720  TRY_TO(TraverseStmt(C->getNumTasks()));
3721  return true;
3722 }
3723 
3724 template <typename Derived>
3725 bool RecursiveASTVisitor<Derived>::VisitOMPHintClause(OMPHintClause *C) {
3726  TRY_TO(TraverseStmt(C->getHint()));
3727  return true;
3728 }
3729 
3730 template <typename Derived>
3731 bool RecursiveASTVisitor<Derived>::VisitOMPDistScheduleClause(
3732  OMPDistScheduleClause *C) {
3733  TRY_TO(VisitOMPClauseWithPreInit(C));
3734  TRY_TO(TraverseStmt(C->getChunkSize()));
3735  return true;
3736 }
3737 
3738 template <typename Derived>
3739 bool
3740 RecursiveASTVisitor<Derived>::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
3741  return true;
3742 }
3743 
3744 template <typename Derived>
3745 bool RecursiveASTVisitor<Derived>::VisitOMPToClause(OMPToClause *C) {
3746  TRY_TO(VisitOMPClauseList(C));
3747  return true;
3748 }
3749 
3750 template <typename Derived>
3751 bool RecursiveASTVisitor<Derived>::VisitOMPFromClause(OMPFromClause *C) {
3752  TRY_TO(VisitOMPClauseList(C));
3753  return true;
3754 }
3755 
3756 template <typename Derived>
3757 bool RecursiveASTVisitor<Derived>::VisitOMPUseDevicePtrClause(
3758  OMPUseDevicePtrClause *C) {
3759  TRY_TO(VisitOMPClauseList(C));
3760  return true;
3761 }
3762 
3763 template <typename Derived>
3764 bool RecursiveASTVisitor<Derived>::VisitOMPUseDeviceAddrClause(
3765  OMPUseDeviceAddrClause *C) {
3766  TRY_TO(VisitOMPClauseList(C));
3767  return true;
3768 }
3769 
3770 template <typename Derived>
3771 bool RecursiveASTVisitor<Derived>::VisitOMPIsDevicePtrClause(
3772  OMPIsDevicePtrClause *C) {
3773  TRY_TO(VisitOMPClauseList(C));
3774  return true;
3775 }
3776 
3777 template <typename Derived>
3778 bool RecursiveASTVisitor<Derived>::VisitOMPHasDeviceAddrClause(
3779  OMPHasDeviceAddrClause *C) {
3780  TRY_TO(VisitOMPClauseList(C));
3781  return true;
3782 }
3783 
3784 template <typename Derived>
3785 bool RecursiveASTVisitor<Derived>::VisitOMPNontemporalClause(
3786  OMPNontemporalClause *C) {
3787  TRY_TO(VisitOMPClauseList(C));
3788  for (auto *E : C->private_refs()) {
3789  TRY_TO(TraverseStmt(E));
3790  }
3791  return true;
3792 }
3793 
3794 template <typename Derived>
3795 bool RecursiveASTVisitor<Derived>::VisitOMPOrderClause(OMPOrderClause *) {
3796  return true;
3797 }
3798 
3799 template <typename Derived>
3800 bool RecursiveASTVisitor<Derived>::VisitOMPDetachClause(OMPDetachClause *C) {
3801  TRY_TO(TraverseStmt(C->getEventHandler()));
3802  return true;
3803 }
3804 
3805 template <typename Derived>
3806 bool RecursiveASTVisitor<Derived>::VisitOMPUsesAllocatorsClause(
3807  OMPUsesAllocatorsClause *C) {
3808  for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
3809  const OMPUsesAllocatorsClause::Data Data = C->getAllocatorData(I);
3810  TRY_TO(TraverseStmt(Data.Allocator));
3811  TRY_TO(TraverseStmt(Data.AllocatorTraits));
3812  }
3813  return true;
3814 }
3815 
3816 template <typename Derived>
3817 bool RecursiveASTVisitor<Derived>::VisitOMPAffinityClause(
3818  OMPAffinityClause *C) {
3819  TRY_TO(TraverseStmt(C->getModifier()));
3820  for (Expr *E : C->varlists())
3821  TRY_TO(TraverseStmt(E));
3822  return true;
3823 }
3824 
3825 template <typename Derived>
3826 bool RecursiveASTVisitor<Derived>::VisitOMPFilterClause(OMPFilterClause *C) {
3827  TRY_TO(VisitOMPClauseWithPreInit(C));
3828  TRY_TO(TraverseStmt(C->getThreadID()));
3829  return true;
3830 }
3831 
3832 template <typename Derived>
3833 bool RecursiveASTVisitor<Derived>::VisitOMPBindClause(OMPBindClause *C) {
3834  return true;
3835 }
3836 
3837 // FIXME: look at the following tricky-seeming exprs to see if we
3838 // need to recurse on anything. These are ones that have methods
3839 // returning decls or qualtypes or nestednamespecifier -- though I'm
3840 // not sure if they own them -- or just seemed very complicated, or
3841 // had lots of sub-types to explore.
3842 //
3843 // VisitOverloadExpr and its children: recurse on template args? etc?
3844 
3845 // FIXME: go through all the stmts and exprs again, and see which of them
3846 // create new types, and recurse on the types (TypeLocs?) of those.
3847 // Candidates:
3848 //
3849 // http://clang.llvm.org/doxygen/classclang_1_1CXXTypeidExpr.html
3850 // http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html
3851 // http://clang.llvm.org/doxygen/classclang_1_1TypesCompatibleExpr.html
3852 // Every class that has getQualifier.
3853 
3854 #undef DEF_TRAVERSE_STMT
3855 #undef TRAVERSE_STMT
3856 #undef TRAVERSE_STMT_BASE
3857 
3858 #undef TRY_TO
3859 
3860 } // end namespace clang
3861 
3862 #endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H
clang::NestedNameSpecifier::Identifier
@ Identifier
An identifier, stored as an IdentifierInfo*.
Definition: NestedNameSpecifier.h:81
clang::NestedNameSpecifier::Super
@ Super
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in.
Definition: NestedNameSpecifier.h:101
clang::DeclContext::decls
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2157
Specifiers.h
clang::DeclarationName::Identifier
@ Identifier
Definition: DeclarationName.h:209
clang::DeclarationName::CXXLiteralOperatorName
@ CXXLiteralOperatorName
Definition: DeclarationName.h:219
clang::for
for(unsigned I=0, E=TL.getNumArgs();I !=E;++I)
Definition: RecursiveASTVisitor.h:1401
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1376
clang::LambdaCapture
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
clang::TemplateArgument::getAsTemplateOrTemplatePattern
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
Definition: TemplateBase.h:299
clang::RecursiveASTVisitor::TraverseConstructorInitializer
bool TraverseConstructorInitializer(CXXCtorInitializer *Init)
Recursively visit a constructor initializer.
Definition: RecursiveASTVisitor.h:948
clang::TemplateArgument::pack_begin
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:351
clang::TemplateArgument::Null
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:67
TRY_TO_TRAVERSE_OR_ENQUEUE_STMT
#define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S)
Definition: RecursiveASTVisitor.h:364
clang::TemplateArgumentLoc::getSourceExpression
Expr * getSourceExpression() const
Definition: TemplateBase.h:520
clang::DeclarationName::CXXConstructorName
@ CXXConstructorName
Definition: DeclarationName.h:212
llvm::SmallVector
Definition: LLVM.h:38
clang::NestedNameSpecifier::NamespaceAlias
@ NamespaceAlias
A namespace alias, stored as a NamespaceAliasDecl*.
Definition: NestedNameSpecifier.h:87
DEF_TRAVERSE_TMPL_SPEC_DECL
#define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND, DECLKIND)
clang::RecursiveASTVisitor::shouldVisitTemplateInstantiations
bool shouldVisitTemplateInstantiations() const
Return whether this visitor should recurse into template instantiations.
Definition: RecursiveASTVisitor.h:180
clang::detail::is_same_method_impl::isSameMethod
static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, SecondMethodPtrTy SecondMethodPtr)
Definition: RecursiveASTVisitor.h:74
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::RecursiveASTVisitor::TraverseType
bool TraverseType(QualType T)
Recursively visit a type, by dispatching to Traverse*Type() based on the argument's getTypeClass() pr...
Definition: RecursiveASTVisitor.h:712
clang::RecursiveASTVisitor::WalkUpFromQualifiedTypeLoc
bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL)
Definition: RecursiveASTVisitor.h:426
clang::RecursiveASTVisitor::canIgnoreChildDeclWhileTraversingDeclContext
bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child)
Definition: RecursiveASTVisitor.h:1487
clang::TSK_Undeclared
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
Definition: Specifiers.h:176
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:731
Attr.h
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:55
clang::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:50
clang::RecursiveASTVisitor::VisitQualifiedTypeLoc
bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL)
Definition: RecursiveASTVisitor.h:429
clang::RecursiveASTVisitor::TraverseLambdaCapture
bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, Expr *Init)
Recursively visit a lambda capture.
Definition: RecursiveASTVisitor.h:961
DeclCXX.h
clang::RecursiveASTVisitor::shouldVisitImplicitCode
bool shouldVisitImplicitCode() const
Return whether this visitor should recurse into implicit code, e.g., implicit constructors and destru...
Definition: RecursiveASTVisitor.h:188
clang::RecursiveASTVisitor::TraverseTemplateArgument
bool TraverseTemplateArgument(const TemplateArgument &Arg)
Recursively visit a template argument and dispatch to the appropriate method for the argument type.
Definition: RecursiveASTVisitor.h:868
clang::TemplateArgument::Declaration
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
Definition: TemplateBase.h:74
clang::DeclarationName::CXXDeductionGuideName
@ CXXDeductionGuideName
Definition: DeclarationName.h:216
DeclOpenMP.h
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4791
clang::concepts::ExprRequirement::getExpr
Expr * getExpr() const
Definition: ExprConcepts.h:395
clang::RecursiveASTVisitor::WalkUpFromUnqualTypeLoc
bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL)
Definition: RecursiveASTVisitor.h:430
clang::detail::isSameMethod
bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, SecondMethodPtrTy SecondMethodPtr)
Returns true if and only if FirstMethodPtr and SecondMethodPtr are pointers to the same non-static me...
Definition: RecursiveASTVisitor.h:91
ExprOpenMP.h
clang::RecursiveASTVisitor::TraverseStmt
bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue=nullptr)
Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...
Definition: RecursiveASTVisitor.h:671
clang::detail::is_same_method_impl< true >::isSameMethod
static bool isSameMethod(FirstMethodPtrTy FirstMethodPtr, SecondMethodPtrTy SecondMethodPtr)
Definition: RecursiveASTVisitor.h:82
clang::TemplateArgument::getAsExpr
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:341
TemplateName.h
clang::DeclarationName::getCXXDeductionGuideTemplate
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name.
Definition: DeclarationName.h:460
clang::ASTContext::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1078
clang::RecursiveASTVisitor::TraverseConceptRequirement
bool TraverseConceptRequirement(concepts::Requirement *R)
Definition: RecursiveASTVisitor.h:540
clang::RecursiveASTVisitor::TraverseTemplateArguments
bool TraverseTemplateArguments(const TemplateArgument *Args, unsigned NumArgs)
Recursively visit a set of template arguments.
Definition: RecursiveASTVisitor.h:938
clang::TemplateArgumentLoc::getTypeSourceInfo
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:514
clang::TemplateArgument::Expression
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
Definition: TemplateBase.h:96
clang::RecursiveASTVisitor::VisitDecl
bool VisitDecl(Decl *D)
Definition: RecursiveASTVisitor.h:455
clang::UnqualTypeLoc
Wrapper of type source information for a type with no direct qualifiers.
Definition: TypeLoc.h:251
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1556
Decl.h
clang::Stmt::NoStmtClass
@ NoStmtClass
Definition: Stmt.h:73
DeclObjC.h
clang::TemplateArgument::Integral
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:82
ExprConcepts.h
clang::TemplateArgument::NullPtr
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:78
U
clang::TRY_TO
TRY_TO(TraverseType(T->getPointeeType()))
clang::RecursiveASTVisitor::dataTraverseStmtPost
bool dataTraverseStmtPost(Stmt *S)
Invoked after visiting a statement or expression via data recursion.
Definition: RecursiveASTVisitor.h:221
clang::concepts::NestedRequirement::getConstraintExpr
Expr * getConstraintExpr() const
Definition: ExprConcepts.h:450
TemplateBase.h
clang::TSK_ExplicitInstantiationDeclaration
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:187
clang::NestedNameSpecifier::Namespace
@ Namespace
A namespace, stored as a NamespaceDecl*.
Definition: NestedNameSpecifier.h:84
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:244
DEF_TRAVERSE_TMPL_DECL
#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND)
DeclTemplate.h
clang::QualifiedTypeLoc
Wrapper of type source information for a type with non-trivial direct qualifiers.
Definition: TypeLoc.h:277
StmtOpenMP.h
Node
DynTypedNode Node
Definition: ASTMatchFinder.cpp:68
DeclFriend.h
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:435
clang::interp::ReturnValue
bool ReturnValue(const T &V, APValue &R)
Convert a value to an APValue.
Definition: Interp.h:42
DeclBase.h
clang::RecursiveASTVisitor::TraverseNestedNameSpecifier
bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS)
Recursively visit a C++ nested-name-specifier.
Definition: RecursiveASTVisitor.h:778
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
DEF_TRAVERSE_STMT
#define DEF_TRAVERSE_STMT(STMT, CODE)
clang::interp::LE
bool LE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:239
clang::DeclarationName::CXXDestructorName
@ CXXDestructorName
Definition: DeclarationName.h:213
clang::RecursiveASTVisitor::TraverseCXXBaseSpecifier
bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base)
Recursively visit a base specifier.
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:208
clang::RecursiveASTVisitor::shouldWalkTypesOfTypeLocs
bool shouldWalkTypesOfTypeLocs() const
Return whether this visitor should recurse into the types of TypeLocs.
Definition: RecursiveASTVisitor.h:184
NestedNameSpecifier.h
clang::RecursiveASTVisitor
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Definition: RecursiveASTVisitor.h:165
clang::concepts::NestedRequirement
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
Definition: ExprConcepts.h:409
clang::RecursiveASTVisitor::TraverseAttr
bool TraverseAttr(Attr *At)
Recursively visit an attribute, by dispatching to Traverse*Attr() based on the argument's dynamic typ...
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
OpenMPKinds.h
clang::concepts::Requirement
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:151
clang::RecursiveASTVisitor::TraverseTemplateArgumentLoc
bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc)
Recursively visit a template argument location and dispatch to the appropriate method for the argumen...
Definition: RecursiveASTVisitor.h:899
clang::DeclarationName::CXXOperatorName
@ CXXOperatorName
Definition: DeclarationName.h:215
clang::DeclarationNameInfo::getNamedTypeInfo
TypeSourceInfo * getNamedTypeInfo() const
getNamedTypeInfo - Returns the source type info associated to the name.
Definition: DeclarationName.h:806
DEF_TRAVERSE_TMPL_INST
#define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND)
Definition: RecursiveASTVisitor.h:467
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
Type.h
clang::DEF_TRAVERSE_DECL
DEF_TRAVERSE_DECL(BlockDecl, { if(TypeSourceInfo *TInfo=D->getSignatureAsWritten()) TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));TRY_TO(TraverseStmt(D->getBody()));for(const auto &I :D->captures()) { if(I.hasCopyExpr()) { TRY_TO(TraverseStmt(I.getCopyExpr()));} } ShouldVisitChildren=false;}) DEF_TRAVERSE_DECL(CapturedDecl
clang::RecursiveASTVisitor::VisitTypeLoc
bool VisitTypeLoc(TypeLoc TL)
Definition: RecursiveASTVisitor.h:422
Expr.h
clang::TemplateArgumentLoc::getArgument
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:506
TRY_TO
#define TRY_TO(CALL_EXPR)
Definition: RecursiveASTVisitor.h:58
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::TSK_ExplicitInstantiationDefinition
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:191
clang::NestedNameSpecifier::Global
@ Global
The global specifier '::'. There is no stored value.
Definition: NestedNameSpecifier.h:97
clang::RecursiveASTVisitor::TraverseConceptExprRequirement
bool TraverseConceptExprRequirement(concepts::ExprRequirement *R)
Definition: RecursiveASTVisitor.h:597
clang::RecursiveASTVisitor::TraverseTemplateName
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
Definition: RecursiveASTVisitor.h:858
clang::DeclarationName::CXXUsingDirective
@ CXXUsingDirective
Definition: DeclarationName.h:222
clang::RecursiveASTVisitor::dataTraverseNode
bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue)
Definition: RecursiveASTVisitor.h:570
ExprObjC.h
clang::RecursiveASTVisitor::VisitUnqualTypeLoc
bool VisitUnqualTypeLoc(UnqualTypeLoc TL)
Definition: RecursiveASTVisitor.h:433
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::TypeLoc::isNull
bool isNull() const
Definition: TypeLoc.h:120
ExprCXX.h
Base
clang::Stmt::child_range
llvm::iterator_range< child_iterator > child_range
Definition: Stmt.h:1254
clang::RecursiveASTVisitor::VisitStmt
bool VisitStmt(Stmt *S)
Definition: RecursiveASTVisitor.h:380
clang::detail::has_same_member_pointer_type
Definition: RecursiveASTVisitor.h:67
ASTConcept.h
This file provides AST data structures related to concepts.
clang::concepts::TypeRequirement::isSubstitutionFailure
bool isSubstitutionFailure() const
Definition: ExprConcepts.h:236
clang::concepts::Requirement::RK_Compound
@ RK_Compound
Definition: ExprConcepts.h:155
clang::concepts::Requirement::RK_Simple
@ RK_Simple
Definition: ExprConcepts.h:155
clang::RecursiveASTVisitor::shouldTraversePostOrder
bool shouldTraversePostOrder() const
Return whether this visitor should traverse post-order.
Definition: RecursiveASTVisitor.h:194
clang::Type::getTypeClass
TypeClass getTypeClass() const
Definition: Type.h:1927
clang::NestedNameSpecifier::TypeSpecWithTemplate
@ TypeSpecWithTemplate
A type that was preceded by the 'template' keyword, stored as a Type*.
Definition: NestedNameSpecifier.h:94
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:565
clang::RecursiveASTVisitor::getDerived
Derived & getDerived()
Return a reference to the derived class.
Definition: RecursiveASTVisitor.h:176
StmtObjC.h
clang::RecursiveASTVisitor::TraverseObjCProtocolLoc
bool TraverseObjCProtocolLoc(ObjCProtocolLoc ProtocolLoc)
Recursively visit an Objective-C protocol reference with location information.
clang::DeclarationNameInfo::getName
DeclarationName getName() const
getName - Returns the embedded declaration name.
Definition: DeclarationName.h:790
clang::DeclarationName::CXXConversionFunctionName
@ CXXConversionFunctionName
Definition: DeclarationName.h:214
clang::DependentTemplateName
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:462
clang::TemplateArgument::TemplateExpansion
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:90
clang::TemplateName::getAsQualifiedTemplateName
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Definition: TemplateName.cpp:163
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::RecursiveASTVisitor::dataTraverseStmtPre
bool dataTraverseStmtPre(Stmt *S)
Invoked before visiting a statement or expression via data recursion.
Definition: RecursiveASTVisitor.h:214
clang::TemplateParameterList::end
iterator end()
Definition: DeclTemplate.h:126
clang::concepts::TypeRequirement
A requires-expression requirement which queries the existence of a type name or type template special...
Definition: ExprConcepts.h:205
clang::TypeLoc::getUnqualifiedLoc
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:326
clang::ConceptReference
Common data class for constructs that reference concepts with template arguments.
Definition: ASTConcept.h:99
clang::if
if(TL.isConstrained())
Definition: RecursiveASTVisitor.h:1375
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:796
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
OpenMPClause.h
clang::TypeLoc
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
clang::RecursiveASTVisitor::TraverseDeclarationNameInfo
bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo)
Recursively visit a name with its location information.
Definition: RecursiveASTVisitor.h:829
clang::DeclarationName::ObjCZeroArgSelector
@ ObjCZeroArgSelector
Definition: DeclarationName.h:210
clang::QualifiedTemplateName
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:405
clang::DeclarationName::ObjCOneArgSelector
@ ObjCOneArgSelector
Definition: DeclarationName.h:211
clang::ShouldVisitChildren
ShouldVisitChildren
Definition: RecursiveASTVisitor.h:1549
LLVM.h
clang::TSK_ExplicitSpecialization
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition: Specifiers.h:183
clang::concepts::TypeRequirement::getType
TypeSourceInfo * getType() const
Definition: ExprConcepts.h:247
clang::NestedNameSpecifierLoc::getPrefix
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
Definition: NestedNameSpecifier.h:327
STMT
#define STMT(CLASS, PARENT)
Definition: RecursiveASTVisitor.h:381
DEF_TRAVERSE_TMPL_PART_SPEC_DECL
#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND)
clang::RecursiveASTVisitor::TraverseConceptTypeRequirement
bool TraverseConceptTypeRequirement(concepts::TypeRequirement *R)
Definition: RecursiveASTVisitor.h:589
clang::RecursiveASTVisitor::DataRecursionQueue
SmallVectorImpl< llvm::PointerIntPair< Stmt *, 1, bool > > DataRecursionQueue
A queue used for performing data recursion over statements.
Definition: RecursiveASTVisitor.h:173
DeclarationName.h
clang::interp::NE
bool NE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:225
clang::TypeLoc::getTypeLocClass
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:115
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:393
clang::DEF_TRAVERSE_TYPELOC
DEF_TRAVERSE_TYPELOC(ComplexType, { TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(PointerType
clang::TemplateArgument::Type
@ Type
The template argument is a type.
Definition: TemplateBase.h:70
clang
Definition: CalledOnceCheck.h:17
clang::NestedNameSpecifier::getAsType
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
Definition: NestedNameSpecifier.h:196
clang::TemplateArgument::Template
@ Template
The template argument is a template name that was provided for a template template parameter.
Definition: TemplateBase.h:86
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:70
clang::RecursiveASTVisitor::VisitType
bool VisitType(Type *T)
Definition: RecursiveASTVisitor.h:401
clang::detail::is_same_method_impl
Definition: RecursiveASTVisitor.h:72
clang::NestedNameSpecifierLoc::getNestedNameSpecifier
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
Definition: NestedNameSpecifier.h:274
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:41
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6530
clang::TemplateParameterList::begin
iterator begin()
Definition: DeclTemplate.h:124
clang::RecursiveASTVisitor::VisitAttr
bool VisitAttr(Attr *A)
Definition: RecursiveASTVisitor.h:332
clang::RecursiveASTVisitor::WalkUpFromDecl
bool WalkUpFromDecl(Decl *D)
Definition: RecursiveASTVisitor.h:454
clang::RecursiveASTVisitor::WalkUpFromStmt
bool WalkUpFromStmt(Stmt *S)
Definition: RecursiveASTVisitor.h:379
clang::NestedNameSpecifier::getPrefix
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
Definition: NestedNameSpecifier.h:169
clang::RecursiveASTVisitor::TraverseDecl
bool TraverseDecl(Decl *D)
Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...
Definition: RecursiveASTVisitor.h:750
clang::DEF_TRAVERSE_TYPE
DEF_TRAVERSE_TYPE(ComplexType, { TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(PointerType
clang::TemplateName::getAsDependentTemplateName
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
Definition: TemplateName.cpp:167
clang::RecursiveASTVisitor::getStmtChildren
Stmt::child_range getStmtChildren(Stmt *S)
Definition: RecursiveASTVisitor.h:341
LambdaCapture.h
clang::QualifiedTypeLoc::getUnqualifiedLoc
UnqualTypeLoc getUnqualifiedLoc() const
Definition: TypeLoc.h:281
clang::RecursiveASTVisitor::TraverseConceptNestedRequirement
bool TraverseConceptNestedRequirement(concepts::NestedRequirement *R)
Definition: RecursiveASTVisitor.h:615
clang::concepts::Requirement::getKind
RequirementKind getKind() const
Definition: ExprConcepts.h:178
clang::NestedNameSpecifier::TypeSpec
@ TypeSpec
A type, stored as a Type*.
Definition: NestedNameSpecifier.h:90
DEF_TRAVERSE_DECL
#define DEF_TRAVERSE_DECL(DECL, CODE)
Definition: RecursiveASTVisitor.h:1513
clang::TemplateArgument::pack_size
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:371
Stmt.h
clang::RecursiveASTVisitor::TraverseTypeConstraint
bool TraverseTypeConstraint(const TypeConstraint *C)
Definition: RecursiveASTVisitor.h:521
clang::concepts::Requirement::RK_Nested
@ RK_Nested
Definition: ExprConcepts.h:155
clang::NestedNameSpecifierLoc::getTypeLoc
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
Definition: NestedNameSpecifier.cpp:453
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::DeclarationName::ObjCMultiArgSelector
@ ObjCMultiArgSelector
Definition: DeclarationName.h:225
true
#define true
Definition: stdbool.h:21
clang::TemplateArgumentLoc::getTemplateQualifierLoc
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:540
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::RecursiveASTVisitor::shouldVisitLambdaBody
bool shouldVisitLambdaBody() const
Return whether this visitor should recurse into lambda body.
Definition: RecursiveASTVisitor.h:191
clang::concepts::ExprRequirement
A requires-expression requirement which queries the validity and properties of an expression ('simple...
Definition: ExprConcepts.h:260
clang::NestedNameSpecifier::getKind
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
Definition: NestedNameSpecifier.cpp:143
clang::concepts::NestedRequirement::isSubstitutionFailure
bool isSubstitutionFailure() const
Definition: ExprConcepts.h:439
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2205
clang::TSK_ImplicitInstantiation
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:179
clang::concepts::Requirement::RK_Type
@ RK_Type
Definition: ExprConcepts.h:155
clang::RecursiveASTVisitor::TraverseSynOrSemInitListExpr
bool TraverseSynOrSemInitListExpr(InitListExpr *S, DataRecursionQueue *Queue=nullptr)
Recursively visit the syntactic or semantic form of an initialization list.
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:767
clang::concepts::ExprRequirement::isExprSubstitutionFailure
bool isExprSubstitutionFailure() const
Definition: ExprConcepts.h:374
clang::RecursiveASTVisitor::WalkUpFromTypeLoc
bool WalkUpFromTypeLoc(TypeLoc TL)
Definition: RecursiveASTVisitor.h:421
clang::ObjCProtocolLoc
Definition: TypeLoc.h:2635
StmtCXX.h
clang::DependentBitIntType
Definition: Type.h:6470
clang::TypeConstraint
Definition: ASTConcept.h:167
clang::RecursiveASTVisitor::TraverseNestedNameSpecifierLoc
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Recursively visit a C++ nested-name-specifier with location information.
Definition: RecursiveASTVisitor.h:803
clang::RecursiveASTVisitor::TraverseAST
bool TraverseAST(ASTContext &AST)
Recursively visits an entire AST, starting from the TranslationUnitDecl.
Definition: RecursiveASTVisitor.h:198
clang::RecursiveASTVisitor::TraverseTypeLoc
bool TraverseTypeLoc(TypeLoc TL)
Recursively visit a type with location, by dispatching to Traverse*TypeLoc() based on the argument ty...
Definition: RecursiveASTVisitor.h:729
clang::concepts::ExprRequirement::getReturnTypeRequirement
const ReturnTypeRequirement & getReturnTypeRequirement() const
Definition: ExprConcepts.h:378
TypeLoc.h
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1227
clang::RecursiveASTVisitor::WalkUpFromType
bool WalkUpFromType(Type *T)
Definition: RecursiveASTVisitor.h:400
TYPE
#define TYPE(CLASS, BASE)
Definition: RecursiveASTVisitor.h:436
clang::TemplateArgument::getAsType
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:268
clang::TypeSourceInfo::getTypeLoc
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:244
clang::TemplateArgument::Pack
@ Pack
The template argument is actually a parameter pack.
Definition: TemplateBase.h:100
Type
MatchType Type
Definition: ASTMatchFinder.cpp:71