clang  3.7.0
DataRecursiveASTVisitor.h
Go to the documentation of this file.
1 //===--- DataRecursiveASTVisitor.h - Data-Recursive AST Visitor -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the DataRecursiveASTVisitor interface, which recursively
11 // traverses the entire AST, using data recursion for Stmts/Exprs.
12 //
13 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_DATARECURSIVEASTVISITOR_H
15 #define LLVM_CLANG_AST_DATARECURSIVEASTVISITOR_H
16 
17 #include "clang/AST/Attr.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclFriend.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclOpenMP.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/Stmt.h"
29 #include "clang/AST/StmtCXX.h"
30 #include "clang/AST/StmtObjC.h"
31 #include "clang/AST/StmtOpenMP.h"
32 #include "clang/AST/TemplateBase.h"
33 #include "clang/AST/TemplateName.h"
34 #include "clang/AST/Type.h"
35 #include "clang/AST/TypeLoc.h"
36 
37 // The following three macros are used for meta programming. The code
38 // using them is responsible for defining macro OPERATOR().
39 
40 // All unary operators.
41 #define UNARYOP_LIST() \
42  OPERATOR(PostInc) OPERATOR(PostDec) OPERATOR(PreInc) OPERATOR(PreDec) \
43  OPERATOR(AddrOf) OPERATOR(Deref) OPERATOR(Plus) OPERATOR(Minus) \
44  OPERATOR(Not) OPERATOR(LNot) OPERATOR(Real) OPERATOR(Imag) \
45  OPERATOR(Extension)
46 
47 // All binary operators (excluding compound assign operators).
48 #define BINOP_LIST() \
49  OPERATOR(PtrMemD) OPERATOR(PtrMemI) OPERATOR(Mul) OPERATOR(Div) \
50  OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) OPERATOR(Shl) OPERATOR(Shr) \
51  OPERATOR(LT) OPERATOR(GT) OPERATOR(LE) OPERATOR(GE) OPERATOR(EQ) \
52  OPERATOR(NE) OPERATOR(And) OPERATOR(Xor) OPERATOR(Or) OPERATOR(LAnd) \
53  OPERATOR(LOr) OPERATOR(Assign) OPERATOR(Comma)
54 
55 // All compound assign operators.
56 #define CAO_LIST() \
57  OPERATOR(Mul) OPERATOR(Div) OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) \
58  OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor)
59 
60 namespace clang {
61 
62 // Reduce the diff between RecursiveASTVisitor / DataRecursiveASTVisitor to
63 // make it easier to track changes and keep the two in sync.
64 #define RecursiveASTVisitor DataRecursiveASTVisitor
65 
66 // A helper macro to implement short-circuiting when recursing. It
67 // invokes CALL_EXPR, which must be a method call, on the derived
68 // object (s.t. a user of RecursiveASTVisitor can override the method
69 // in CALL_EXPR).
70 #define TRY_TO(CALL_EXPR) \
71  do { \
72  if (!getDerived().CALL_EXPR) \
73  return false; \
74  } while (0)
75 
76 /// \brief A class that does preorder depth-first traversal on the
77 /// entire Clang AST and visits each node.
78 ///
79 /// This class performs three distinct tasks:
80 /// 1. traverse the AST (i.e. go to each node);
81 /// 2. at a given node, walk up the class hierarchy, starting from
82 /// the node's dynamic type, until the top-most class (e.g. Stmt,
83 /// Decl, or Type) is reached.
84 /// 3. given a (node, class) combination, where 'class' is some base
85 /// class of the dynamic type of 'node', call a user-overridable
86 /// function to actually visit the node.
87 ///
88 /// These tasks are done by three groups of methods, respectively:
89 /// 1. TraverseDecl(Decl *x) does task #1. It is the entry point
90 /// for traversing an AST rooted at x. This method simply
91 /// dispatches (i.e. forwards) to TraverseFoo(Foo *x) where Foo
92 /// is the dynamic type of *x, which calls WalkUpFromFoo(x) and
93 /// then recursively visits the child nodes of x.
94 /// TraverseStmt(Stmt *x) and TraverseType(QualType x) work
95 /// similarly.
96 /// 2. WalkUpFromFoo(Foo *x) does task #2. It does not try to visit
97 /// any child node of x. Instead, it first calls WalkUpFromBar(x)
98 /// where Bar is the direct parent class of Foo (unless Foo has
99 /// no parent), and then calls VisitFoo(x) (see the next list item).
100 /// 3. VisitFoo(Foo *x) does task #3.
101 ///
102 /// These three method groups are tiered (Traverse* > WalkUpFrom* >
103 /// Visit*). A method (e.g. Traverse*) may call methods from the same
104 /// tier (e.g. other Traverse*) or one tier lower (e.g. WalkUpFrom*).
105 /// It may not call methods from a higher tier.
106 ///
107 /// Note that since WalkUpFromFoo() calls WalkUpFromBar() (where Bar
108 /// is Foo's super class) before calling VisitFoo(), the result is
109 /// that the Visit*() methods for a given node are called in the
110 /// top-down order (e.g. for a node of type NamespaceDecl, the order will
111 /// be VisitDecl(), VisitNamedDecl(), and then VisitNamespaceDecl()).
112 ///
113 /// This scheme guarantees that all Visit*() calls for the same AST
114 /// node are grouped together. In other words, Visit*() methods for
115 /// different nodes are never interleaved.
116 ///
117 /// Stmts are traversed internally using a data queue to avoid a stack overflow
118 /// with hugely nested ASTs.
119 ///
120 /// Clients of this visitor should subclass the visitor (providing
121 /// themselves as the template argument, using the curiously recurring
122 /// template pattern) and override any of the Traverse*, WalkUpFrom*,
123 /// and Visit* methods for declarations, types, statements,
124 /// expressions, or other AST nodes where the visitor should customize
125 /// behavior. Most users only need to override Visit*. Advanced
126 /// users may override Traverse* and WalkUpFrom* to implement custom
127 /// traversal strategies. Returning false from one of these overridden
128 /// functions will abort the entire traversal.
129 ///
130 /// By default, this visitor tries to visit every part of the explicit
131 /// source code exactly once. The default policy towards templates
132 /// is to descend into the 'pattern' class or function body, not any
133 /// explicit or implicit instantiations. Explicit specializations
134 /// are still visited, and the patterns of partial specializations
135 /// are visited separately. This behavior can be changed by
136 /// overriding shouldVisitTemplateInstantiations() in the derived class
137 /// to return true, in which case all known implicit and explicit
138 /// instantiations will be visited at the same time as the pattern
139 /// from which they were produced.
140 template <typename Derived> class RecursiveASTVisitor {
141 public:
142  /// \brief Return a reference to the derived class.
143  Derived &getDerived() { return *static_cast<Derived *>(this); }
144 
145  /// \brief Return whether this visitor should recurse into
146  /// template instantiations.
147  bool shouldVisitTemplateInstantiations() const { return false; }
148 
149  /// \brief Return whether this visitor should recurse into the types of
150  /// TypeLocs.
151  bool shouldWalkTypesOfTypeLocs() const { return true; }
152 
153  /// \brief Recursively visit a statement or expression, by
154  /// dispatching to Traverse*() based on the argument's dynamic type.
155  ///
156  /// \returns false if the visitation was terminated early, true
157  /// otherwise (including when the argument is NULL).
158  bool TraverseStmt(Stmt *S);
159 
160  /// \brief Recursively visit a type, by dispatching to
161  /// Traverse*Type() based on the argument's getTypeClass() property.
162  ///
163  /// \returns false if the visitation was terminated early, true
164  /// otherwise (including when the argument is a Null type).
165  bool TraverseType(QualType T);
166 
167  /// \brief Recursively visit a type with location, by dispatching to
168  /// Traverse*TypeLoc() based on the argument type's getTypeClass() property.
169  ///
170  /// \returns false if the visitation was terminated early, true
171  /// otherwise (including when the argument is a Null type location).
172  bool TraverseTypeLoc(TypeLoc TL);
173 
174  /// \brief Recursively visit an attribute, by dispatching to
175  /// Traverse*Attr() based on the argument's dynamic type.
176  ///
177  /// \returns false if the visitation was terminated early, true
178  /// otherwise (including when the argument is a Null type location).
179  bool TraverseAttr(Attr *At);
180 
181  /// \brief Recursively visit a declaration, by dispatching to
182  /// Traverse*Decl() based on the argument's dynamic type.
183  ///
184  /// \returns false if the visitation was terminated early, true
185  /// otherwise (including when the argument is NULL).
186  bool TraverseDecl(Decl *D);
187 
188  /// \brief Recursively visit a C++ nested-name-specifier.
189  ///
190  /// \returns false if the visitation was terminated early, true otherwise.
192 
193  /// \brief Recursively visit a C++ nested-name-specifier with location
194  /// information.
195  ///
196  /// \returns false if the visitation was terminated early, true otherwise.
198 
199  /// \brief Recursively visit a name with its location information.
200  ///
201  /// \returns false if the visitation was terminated early, true otherwise.
203 
204  /// \brief Recursively visit a template name and dispatch to the
205  /// appropriate method.
206  ///
207  /// \returns false if the visitation was terminated early, true otherwise.
208  bool TraverseTemplateName(TemplateName Template);
209 
210  /// \brief Recursively visit a template argument and dispatch to the
211  /// appropriate method for the argument type.
212  ///
213  /// \returns false if the visitation was terminated early, true otherwise.
214  // FIXME: migrate callers to TemplateArgumentLoc instead.
216 
217  /// \brief Recursively visit a template argument location and dispatch to the
218  /// appropriate method for the argument type.
219  ///
220  /// \returns false if the visitation was terminated early, true otherwise.
222 
223  /// \brief Recursively visit a set of template arguments.
224  /// This can be overridden by a subclass, but it's not expected that
225  /// will be needed -- this visitor always dispatches to another.
226  ///
227  /// \returns false if the visitation was terminated early, true otherwise.
228  // FIXME: take a TemplateArgumentLoc* (or TemplateArgumentListInfo) instead.
230  unsigned NumArgs);
231 
232  /// \brief Recursively visit a constructor initializer. This
233  /// automatically dispatches to another visitor for the initializer
234  /// expression, but not for the name of the initializer, so may
235  /// be overridden for clients that need access to the name.
236  ///
237  /// \returns false if the visitation was terminated early, true otherwise.
239 
240  /// \brief Recursively visit a lambda capture.
241  ///
242  /// \returns false if the visitation was terminated early, true otherwise.
244 
245  /// \brief Recursively visit the body of a lambda expression.
246  ///
247  /// This provides a hook for visitors that need more context when visiting
248  /// \c LE->getBody().
249  ///
250  /// \returns false if the visitation was terminated early, true otherwise.
251  bool TraverseLambdaBody(LambdaExpr *LE);
252 
253  // ---- Methods on Attrs ----
254 
255  // \brief Visit an attribute.
256  bool VisitAttr(Attr *A) { return true; }
257 
258 // Declare Traverse* and empty Visit* for all Attr classes.
259 #define ATTR_VISITOR_DECLS_ONLY
260 #include "clang/AST/AttrVisitor.inc"
261 #undef ATTR_VISITOR_DECLS_ONLY
262 
263 // ---- Methods on Stmts ----
264 
265 // Declare Traverse*() for all concrete Stmt classes.
266 #define ABSTRACT_STMT(STMT)
267 #define STMT(CLASS, PARENT) bool Traverse##CLASS(CLASS *S);
268 #include "clang/AST/StmtNodes.inc"
269  // The above header #undefs ABSTRACT_STMT and STMT upon exit.
270 
271  // Define WalkUpFrom*() and empty Visit*() for all Stmt classes.
272  bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); }
273  bool VisitStmt(Stmt *S) { return true; }
274 #define STMT(CLASS, PARENT) \
275  bool WalkUpFrom##CLASS(CLASS *S) { \
276  TRY_TO(WalkUpFrom##PARENT(S)); \
277  TRY_TO(Visit##CLASS(S)); \
278  return true; \
279  } \
280  bool Visit##CLASS(CLASS *S) { return true; }
281 #include "clang/AST/StmtNodes.inc"
282 
283 // Define Traverse*(), WalkUpFrom*(), and Visit*() for unary
284 // operator methods. Unary operators are not classes in themselves
285 // (they're all opcodes in UnaryOperator) but do have visitors.
286 #define OPERATOR(NAME) \
287  bool TraverseUnary##NAME(UnaryOperator *S) { \
288  TRY_TO(WalkUpFromUnary##NAME(S)); \
289  StmtQueueAction StmtQueue(*this); \
290  StmtQueue.queue(S->getSubExpr()); \
291  return true; \
292  } \
293  bool WalkUpFromUnary##NAME(UnaryOperator *S) { \
294  TRY_TO(WalkUpFromUnaryOperator(S)); \
295  TRY_TO(VisitUnary##NAME(S)); \
296  return true; \
297  } \
298  bool VisitUnary##NAME(UnaryOperator *S) { return true; }
299 
300  UNARYOP_LIST()
301 #undef OPERATOR
302 
303 // Define Traverse*(), WalkUpFrom*(), and Visit*() for binary
304 // operator methods. Binary operators are not classes in themselves
305 // (they're all opcodes in BinaryOperator) but do have visitors.
306 #define GENERAL_BINOP_FALLBACK(NAME, BINOP_TYPE) \
307  bool TraverseBin##NAME(BINOP_TYPE *S) { \
308  TRY_TO(WalkUpFromBin##NAME(S)); \
309  StmtQueueAction StmtQueue(*this); \
310  StmtQueue.queue(S->getLHS()); \
311  StmtQueue.queue(S->getRHS()); \
312  return true; \
313  } \
314  bool WalkUpFromBin##NAME(BINOP_TYPE *S) { \
315  TRY_TO(WalkUpFrom##BINOP_TYPE(S)); \
316  TRY_TO(VisitBin##NAME(S)); \
317  return true; \
318  } \
319  bool VisitBin##NAME(BINOP_TYPE *S) { return true; }
320 
321 #define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME, BinaryOperator)
322  BINOP_LIST()
323 #undef OPERATOR
324 
325 // Define Traverse*(), WalkUpFrom*(), and Visit*() for compound
326 // assignment methods. Compound assignment operators are not
327 // classes in themselves (they're all opcodes in
328 // CompoundAssignOperator) but do have visitors.
329 #define OPERATOR(NAME) \
330  GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator)
331 
332  CAO_LIST()
333 #undef OPERATOR
334 #undef GENERAL_BINOP_FALLBACK
335 
336 // ---- Methods on Types ----
337 // FIXME: revamp to take TypeLoc's rather than Types.
338 
339 // Declare Traverse*() for all concrete Type classes.
340 #define ABSTRACT_TYPE(CLASS, BASE)
341 #define TYPE(CLASS, BASE) bool Traverse##CLASS##Type(CLASS##Type *T);
342 #include "clang/AST/TypeNodes.def"
343  // The above header #undefs ABSTRACT_TYPE and TYPE upon exit.
344 
345  // Define WalkUpFrom*() and empty Visit*() for all Type classes.
346  bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); }
347  bool VisitType(Type *T) { return true; }
348 #define TYPE(CLASS, BASE) \
349  bool WalkUpFrom##CLASS##Type(CLASS##Type *T) { \
350  TRY_TO(WalkUpFrom##BASE(T)); \
351  TRY_TO(Visit##CLASS##Type(T)); \
352  return true; \
353  } \
354  bool Visit##CLASS##Type(CLASS##Type *T) { return true; }
355 #include "clang/AST/TypeNodes.def"
356 
357 // ---- Methods on TypeLocs ----
358 // FIXME: this currently just calls the matching Type methods
359 
360 // Declare Traverse*() for all concrete TypeLoc classes.
361 #define ABSTRACT_TYPELOC(CLASS, BASE)
362 #define TYPELOC(CLASS, BASE) bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL);
363 #include "clang/AST/TypeLocNodes.def"
364  // The above header #undefs ABSTRACT_TYPELOC and TYPELOC upon exit.
365 
366  // Define WalkUpFrom*() and empty Visit*() for all TypeLoc classes.
367  bool WalkUpFromTypeLoc(TypeLoc TL) { return getDerived().VisitTypeLoc(TL); }
368  bool VisitTypeLoc(TypeLoc TL) { return true; }
369 
370  // QualifiedTypeLoc and UnqualTypeLoc are not declared in
371  // TypeNodes.def and thus need to be handled specially.
373  return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
374  }
375  bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { return true; }
377  return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc());
378  }
379  bool VisitUnqualTypeLoc(UnqualTypeLoc TL) { return true; }
380 
381 // Note that BASE includes trailing 'Type' which CLASS doesn't.
382 #define TYPE(CLASS, BASE) \
383  bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) { \
384  TRY_TO(WalkUpFrom##BASE##Loc(TL)); \
385  TRY_TO(Visit##CLASS##TypeLoc(TL)); \
386  return true; \
387  } \
388  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; }
389 #include "clang/AST/TypeNodes.def"
390 
391 // ---- Methods on Decls ----
392 
393 // Declare Traverse*() for all concrete Decl classes.
394 #define ABSTRACT_DECL(DECL)
395 #define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D);
396 #include "clang/AST/DeclNodes.inc"
397  // The above header #undefs ABSTRACT_DECL and DECL upon exit.
398 
399  // Define WalkUpFrom*() and empty Visit*() for all Decl classes.
400  bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); }
401  bool VisitDecl(Decl *D) { return true; }
402 #define DECL(CLASS, BASE) \
403  bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) { \
404  TRY_TO(WalkUpFrom##BASE(D)); \
405  TRY_TO(Visit##CLASS##Decl(D)); \
406  return true; \
407  } \
408  bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; }
409 #include "clang/AST/DeclNodes.inc"
410 
411 private:
412  // These are helper methods used by more than one Traverse* method.
413  bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL);
414  bool TraverseClassInstantiations(ClassTemplateDecl *D);
415  bool TraverseVariableInstantiations(VarTemplateDecl *D);
416  bool TraverseFunctionInstantiations(FunctionTemplateDecl *D);
417  bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL,
418  unsigned Count);
419  bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL);
420  bool TraverseRecordHelper(RecordDecl *D);
421  bool TraverseCXXRecordHelper(CXXRecordDecl *D);
422  bool TraverseDeclaratorHelper(DeclaratorDecl *D);
423  bool TraverseDeclContextHelper(DeclContext *DC);
424  bool TraverseFunctionHelper(FunctionDecl *D);
425  bool TraverseVarHelper(VarDecl *D);
426  bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
427  bool TraverseOMPLoopDirective(OMPLoopDirective *S);
428  bool TraverseOMPClause(OMPClause *C);
429 #define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C);
430 #include "clang/Basic/OpenMPKinds.def"
431  /// \brief Process clauses with list of variables.
432  template <typename T> bool VisitOMPClauseList(T *Node);
433 
434  typedef SmallVector<Stmt *, 16> StmtsTy;
435  typedef SmallVector<StmtsTy *, 4> QueuesTy;
436 
437  QueuesTy Queues;
438 
439  class NewQueueRAII {
440  RecursiveASTVisitor &RAV;
441 
442  public:
443  NewQueueRAII(StmtsTy &queue, RecursiveASTVisitor &RAV) : RAV(RAV) {
444  RAV.Queues.push_back(&queue);
445  }
446  ~NewQueueRAII() { RAV.Queues.pop_back(); }
447  };
448 
449  StmtsTy &getCurrentQueue() {
450  assert(!Queues.empty() && "base TraverseStmt was never called?");
451  return *Queues.back();
452  }
453 
454 public:
456  StmtsTy &CurrQueue;
457 
458  public:
460  : CurrQueue(RAV.getCurrentQueue()) {}
461 
462  void queue(Stmt *S) { CurrQueue.push_back(S); }
463  };
464 };
465 
466 #define DISPATCH(NAME, CLASS, VAR) \
467  return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR))
468 
469 template <typename Derived>
471  if (!S)
472  return true;
473 
474  StmtsTy Queue, StmtsToEnqueue;
475  Queue.push_back(S);
476  NewQueueRAII NQ(StmtsToEnqueue, *this);
477 
478  while (!Queue.empty()) {
479  S = Queue.pop_back_val();
480  if (!S)
481  continue;
482 
483  StmtsToEnqueue.clear();
484 
485 #define DISPATCH_STMT(NAME, CLASS, VAR) \
486  TRY_TO(Traverse##NAME(static_cast<CLASS *>(VAR))); \
487  break
488 
489  // If we have a binary expr, dispatch to the subcode of the binop. A smart
490  // optimizer (e.g. LLVM) will fold this comparison into the switch stmt
491  // below.
492  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) {
493  switch (BinOp->getOpcode()) {
494 #define OPERATOR(NAME) \
495  case BO_##NAME: \
496  DISPATCH_STMT(Bin##NAME, BinaryOperator, S);
497 
498  BINOP_LIST()
499 #undef OPERATOR
500 #undef BINOP_LIST
501 
502 #define OPERATOR(NAME) \
503  case BO_##NAME##Assign: \
504  DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S);
505 
506  CAO_LIST()
507 #undef OPERATOR
508 #undef CAO_LIST
509  }
510  } else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) {
511  switch (UnOp->getOpcode()) {
512 #define OPERATOR(NAME) \
513  case UO_##NAME: \
514  DISPATCH_STMT(Unary##NAME, UnaryOperator, S);
515 
516  UNARYOP_LIST()
517 #undef OPERATOR
518 #undef UNARYOP_LIST
519  }
520  } else {
521 
522  // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt.
523  switch (S->getStmtClass()) {
524  case Stmt::NoStmtClass:
525  break;
526 #define ABSTRACT_STMT(STMT)
527 #define STMT(CLASS, PARENT) \
528  case Stmt::CLASS##Class: \
529  DISPATCH_STMT(CLASS, CLASS, S);
530 #include "clang/AST/StmtNodes.inc"
531  }
532  }
533 
534  Queue.append(StmtsToEnqueue.rbegin(), StmtsToEnqueue.rend());
535  }
536 
537  return true;
538 }
539 
540 #undef DISPATCH_STMT
541 
542 template <typename Derived>
544  if (T.isNull())
545  return true;
546 
547  switch (T->getTypeClass()) {
548 #define ABSTRACT_TYPE(CLASS, BASE)
549 #define TYPE(CLASS, BASE) \
550  case Type::CLASS: \
551  DISPATCH(CLASS##Type, CLASS##Type, const_cast<Type *>(T.getTypePtr()));
552 #include "clang/AST/TypeNodes.def"
553  }
554 
555  return true;
556 }
557 
558 template <typename Derived>
560  if (TL.isNull())
561  return true;
562 
563  switch (TL.getTypeLocClass()) {
564 #define ABSTRACT_TYPELOC(CLASS, BASE)
565 #define TYPELOC(CLASS, BASE) \
566  case TypeLoc::CLASS: \
567  return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>());
568 #include "clang/AST/TypeLocNodes.def"
569  }
570 
571  return true;
572 }
573 
574 // Define the Traverse*Attr(Attr* A) methods
575 #define VISITORCLASS RecursiveASTVisitor
576 #include "clang/AST/AttrVisitor.inc"
577 #undef VISITORCLASS
578 
579 template <typename Derived>
581  if (!D)
582  return true;
583 
584  // As a syntax visitor, we want to ignore declarations for
585  // implicitly-defined declarations (ones not typed explicitly by the
586  // user).
587  if (D->isImplicit())
588  return true;
589 
590  switch (D->getKind()) {
591 #define ABSTRACT_DECL(DECL)
592 #define DECL(CLASS, BASE) \
593  case Decl::CLASS: \
594  if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D))) \
595  return false; \
596  break;
597 #include "clang/AST/DeclNodes.inc"
598  }
599 
600  // Visit any attributes attached to this declaration.
601  for (auto *I : D->attrs()) {
602  if (!getDerived().TraverseAttr(I))
603  return false;
604  }
605  return true;
606 }
607 
608 #undef DISPATCH
609 
610 template <typename Derived>
612  NestedNameSpecifier *NNS) {
613  if (!NNS)
614  return true;
615 
616  if (NNS->getPrefix())
617  TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix()));
618 
619  switch (NNS->getKind()) {
625  return true;
626 
629  TRY_TO(TraverseType(QualType(NNS->getAsType(), 0)));
630  }
631 
632  return true;
633 }
634 
635 template <typename Derived>
638  if (!NNS)
639  return true;
640 
641  if (NestedNameSpecifierLoc Prefix = NNS.getPrefix())
642  TRY_TO(TraverseNestedNameSpecifierLoc(Prefix));
643 
644  switch (NNS.getNestedNameSpecifier()->getKind()) {
650  return true;
651 
654  TRY_TO(TraverseTypeLoc(NNS.getTypeLoc()));
655  break;
656  }
657 
658  return true;
659 }
660 
661 template <typename Derived>
663  DeclarationNameInfo NameInfo) {
664  switch (NameInfo.getName().getNameKind()) {
668  if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo())
669  TRY_TO(TraverseTypeLoc(TSInfo->getTypeLoc()));
670 
671  break;
672 
680  break;
681  }
682 
683  return true;
684 }
685 
686 template <typename Derived>
689  TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier()));
690  else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
691  TRY_TO(TraverseNestedNameSpecifier(QTN->getQualifier()));
692 
693  return true;
694 }
695 
696 template <typename Derived>
698  const TemplateArgument &Arg) {
699  switch (Arg.getKind()) {
704  return true;
705 
707  return getDerived().TraverseType(Arg.getAsType());
708 
711  return getDerived().TraverseTemplateName(
713 
715  return getDerived().TraverseStmt(Arg.getAsExpr());
716 
718  return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
719  Arg.pack_size());
720  }
721 
722  return true;
723 }
724 
725 // FIXME: no template name location?
726 // FIXME: no source locations for a template argument pack?
727 template <typename Derived>
729  const TemplateArgumentLoc &ArgLoc) {
730  const TemplateArgument &Arg = ArgLoc.getArgument();
731 
732  switch (Arg.getKind()) {
737  return true;
738 
739  case TemplateArgument::Type: {
740  // FIXME: how can TSI ever be NULL?
741  if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo())
742  return getDerived().TraverseTypeLoc(TSI->getTypeLoc());
743  else
744  return getDerived().TraverseType(Arg.getAsType());
745  }
746 
749  if (ArgLoc.getTemplateQualifierLoc())
750  TRY_TO(getDerived().TraverseNestedNameSpecifierLoc(
751  ArgLoc.getTemplateQualifierLoc()));
752  return getDerived().TraverseTemplateName(
754 
756  return getDerived().TraverseStmt(ArgLoc.getSourceExpression());
757 
759  return getDerived().TraverseTemplateArguments(Arg.pack_begin(),
760  Arg.pack_size());
761  }
762 
763  return true;
764 }
765 
766 template <typename Derived>
768  const TemplateArgument *Args, unsigned NumArgs) {
769  for (unsigned I = 0; I != NumArgs; ++I) {
770  TRY_TO(TraverseTemplateArgument(Args[I]));
771  }
772 
773  return true;
774 }
775 
776 template <typename Derived>
778  CXXCtorInitializer *Init) {
779  if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
780  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
781 
782  if (Init->isWritten())
783  TRY_TO(TraverseStmt(Init->getInit()));
784  return true;
785 }
786 
787 template <typename Derived>
788 bool
790  const LambdaCapture *C) {
791  if (LE->isInitCapture(C))
792  TRY_TO(TraverseDecl(C->getCapturedVar()));
793  return true;
794 }
795 
796 template <typename Derived>
798  StmtQueueAction StmtQueue(*this);
799  StmtQueue.queue(LE->getBody());
800  return true;
801 }
802 
803 // ----------------- Type traversal -----------------
804 
805 // This macro makes available a variable T, the passed-in type.
806 #define DEF_TRAVERSE_TYPE(TYPE, CODE) \
807  template <typename Derived> \
808  bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) { \
809  TRY_TO(WalkUpFrom##TYPE(T)); \
810  { CODE; } \
811  return true; \
812  }
813 
814 DEF_TRAVERSE_TYPE(BuiltinType, {})
815 
816 DEF_TRAVERSE_TYPE(ComplexType, { TRY_TO(TraverseType(T->getElementType())); })
817 
818 DEF_TRAVERSE_TYPE(PointerType, { TRY_TO(TraverseType(T->getPointeeType())); })
819 
820 DEF_TRAVERSE_TYPE(BlockPointerType,
821  { TRY_TO(TraverseType(T->getPointeeType())); })
822 
823 DEF_TRAVERSE_TYPE(LValueReferenceType,
824  { TRY_TO(TraverseType(T->getPointeeType())); })
825 
826 DEF_TRAVERSE_TYPE(RValueReferenceType,
827  { TRY_TO(TraverseType(T->getPointeeType())); })
828 
829 DEF_TRAVERSE_TYPE(MemberPointerType, {
830  TRY_TO(TraverseType(QualType(T->getClass(), 0)));
831  TRY_TO(TraverseType(T->getPointeeType()));
832 })
833 
834 DEF_TRAVERSE_TYPE(AdjustedType, { TRY_TO(TraverseType(T->getOriginalType())); })
835 
836 DEF_TRAVERSE_TYPE(DecayedType, { TRY_TO(TraverseType(T->getOriginalType())); })
837 
838 DEF_TRAVERSE_TYPE(ConstantArrayType,
839  { TRY_TO(TraverseType(T->getElementType())); })
840 
841 DEF_TRAVERSE_TYPE(IncompleteArrayType,
842  { TRY_TO(TraverseType(T->getElementType())); })
843 
844 DEF_TRAVERSE_TYPE(VariableArrayType, {
845  TRY_TO(TraverseType(T->getElementType()));
846  TRY_TO(TraverseStmt(T->getSizeExpr()));
847 })
848 
849 DEF_TRAVERSE_TYPE(DependentSizedArrayType, {
850  TRY_TO(TraverseType(T->getElementType()));
851  if (T->getSizeExpr())
852  TRY_TO(TraverseStmt(T->getSizeExpr()));
853 })
854 
855 DEF_TRAVERSE_TYPE(DependentSizedExtVectorType, {
856  if (T->getSizeExpr())
857  TRY_TO(TraverseStmt(T->getSizeExpr()));
858  TRY_TO(TraverseType(T->getElementType()));
859 })
860 
861 DEF_TRAVERSE_TYPE(VectorType, { TRY_TO(TraverseType(T->getElementType())); })
862 
863 DEF_TRAVERSE_TYPE(ExtVectorType, { TRY_TO(TraverseType(T->getElementType())); })
864 
865 DEF_TRAVERSE_TYPE(FunctionNoProtoType,
866  { TRY_TO(TraverseType(T->getReturnType())); })
867 
868 DEF_TRAVERSE_TYPE(FunctionProtoType, {
869  TRY_TO(TraverseType(T->getReturnType()));
870 
871  for (const auto &A : T->param_types()) {
872  TRY_TO(TraverseType(A));
873  }
874 
875  for (const auto &E : T->exceptions()) {
876  TRY_TO(TraverseType(E));
877  }
878 
879  if (Expr *NE = T->getNoexceptExpr())
880  TRY_TO(TraverseStmt(NE));
881 })
882 
883 DEF_TRAVERSE_TYPE(UnresolvedUsingType, {})
884 DEF_TRAVERSE_TYPE(TypedefType, {})
885 
886 DEF_TRAVERSE_TYPE(TypeOfExprType,
887  { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
888 
889 DEF_TRAVERSE_TYPE(TypeOfType, { TRY_TO(TraverseType(T->getUnderlyingType())); })
890 
891 DEF_TRAVERSE_TYPE(DecltypeType,
892  { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
893 
894 DEF_TRAVERSE_TYPE(UnaryTransformType, {
895  TRY_TO(TraverseType(T->getBaseType()));
896  TRY_TO(TraverseType(T->getUnderlyingType()));
897 })
898 
899 DEF_TRAVERSE_TYPE(AutoType, { TRY_TO(TraverseType(T->getDeducedType())); })
900 
901 DEF_TRAVERSE_TYPE(RecordType, {})
902 DEF_TRAVERSE_TYPE(EnumType, {})
903 DEF_TRAVERSE_TYPE(TemplateTypeParmType, {})
904 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType, {})
905 DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, {})
906 
907 DEF_TRAVERSE_TYPE(TemplateSpecializationType, {
908  TRY_TO(TraverseTemplateName(T->getTemplateName()));
909  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
910 })
911 
912 DEF_TRAVERSE_TYPE(InjectedClassNameType, {})
913 
914 DEF_TRAVERSE_TYPE(AttributedType,
915  { TRY_TO(TraverseType(T->getModifiedType())); })
916 
917 DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); })
918 
919 DEF_TRAVERSE_TYPE(ElaboratedType, {
920  if (T->getQualifier()) {
921  TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
922  }
923  TRY_TO(TraverseType(T->getNamedType()));
924 })
925 
926 DEF_TRAVERSE_TYPE(DependentNameType,
927  { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); })
928 
929 DEF_TRAVERSE_TYPE(DependentTemplateSpecializationType, {
930  TRY_TO(TraverseNestedNameSpecifier(T->getQualifier()));
931  TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs()));
932 })
933 
934 DEF_TRAVERSE_TYPE(PackExpansionType, { TRY_TO(TraverseType(T->getPattern())); })
935 
936 DEF_TRAVERSE_TYPE(ObjCInterfaceType, {})
937 
938 DEF_TRAVERSE_TYPE(ObjCObjectType, {
939  // We have to watch out here because an ObjCInterfaceType's base
940  // type is itself.
941  if (T->getBaseType().getTypePtr() != T)
942  TRY_TO(TraverseType(T->getBaseType()));
943  for (auto typeArg : T->getTypeArgsAsWritten()) {
944  TRY_TO(TraverseType(typeArg));
945  }
946 })
947 
948 DEF_TRAVERSE_TYPE(ObjCObjectPointerType,
949  { TRY_TO(TraverseType(T->getPointeeType())); })
950 
951 DEF_TRAVERSE_TYPE(AtomicType, { TRY_TO(TraverseType(T->getValueType())); })
952 
953 #undef DEF_TRAVERSE_TYPE
954 
955 // ----------------- TypeLoc traversal -----------------
956 
957 // This macro makes available a variable TL, the passed-in TypeLoc.
958 // If requested, it calls WalkUpFrom* for the Type in the given TypeLoc,
959 // in addition to WalkUpFrom* for the TypeLoc itself, such that existing
960 // clients that override the WalkUpFrom*Type() and/or Visit*Type() methods
961 // continue to work.
962 #define DEF_TRAVERSE_TYPELOC(TYPE, CODE) \
963  template <typename Derived> \
964  bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) { \
965  if (getDerived().shouldWalkTypesOfTypeLocs()) \
966  TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \
967  TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \
968  { CODE; } \
969  return true; \
970  }
971 
972 template <typename Derived>
973 bool
974 RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) {
975  // Move this over to the 'main' typeloc tree. Note that this is a
976  // move -- we pretend that we were really looking at the unqualified
977  // typeloc all along -- rather than a recursion, so we don't follow
978  // the normal CRTP plan of going through
979  // getDerived().TraverseTypeLoc. If we did, we'd be traversing
980  // twice for the same type (once as a QualifiedTypeLoc version of
981  // the type, once as an UnqualifiedTypeLoc version of the type),
982  // which in effect means we'd call VisitTypeLoc twice with the
983  // 'same' type. This solves that problem, at the cost of never
984  // seeing the qualified version of the type (unless the client
985  // subclasses TraverseQualifiedTypeLoc themselves). It's not a
986  // perfect solution. A perfect solution probably requires making
987  // QualifiedTypeLoc a wrapper around TypeLoc -- like QualType is a
988  // wrapper around Type* -- rather than being its own class in the
989  // type hierarchy.
990  return TraverseTypeLoc(TL.getUnqualifiedLoc());
991 }
992 
993 DEF_TRAVERSE_TYPELOC(BuiltinType, {})
994 
995 // FIXME: ComplexTypeLoc is unfinished
996 DEF_TRAVERSE_TYPELOC(ComplexType, {
997  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
998 })
999 
1000 DEF_TRAVERSE_TYPELOC(PointerType,
1001  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1002 
1003 DEF_TRAVERSE_TYPELOC(BlockPointerType,
1004  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1005 
1006 DEF_TRAVERSE_TYPELOC(LValueReferenceType,
1007  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1008 
1009 DEF_TRAVERSE_TYPELOC(RValueReferenceType,
1010  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1011 
1012 // FIXME: location of base class?
1013 // We traverse this in the type case as well, but how is it not reached through
1014 // the pointee type?
1015 DEF_TRAVERSE_TYPELOC(MemberPointerType, {
1016  TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0)));
1017  TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));
1018 })
1019 
1020 DEF_TRAVERSE_TYPELOC(AdjustedType,
1021  { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1022 
1023 DEF_TRAVERSE_TYPELOC(DecayedType,
1024  { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); })
1025 
1026 template <typename Derived>
1028  // This isn't available for ArrayType, but is for the ArrayTypeLoc.
1029  TRY_TO(TraverseStmt(TL.getSizeExpr()));
1030  return true;
1031 }
1032 
1033 DEF_TRAVERSE_TYPELOC(ConstantArrayType, {
1034  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1035  return TraverseArrayTypeLocHelper(TL);
1036 })
1037 
1038 DEF_TRAVERSE_TYPELOC(IncompleteArrayType, {
1039  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1040  return TraverseArrayTypeLocHelper(TL);
1041 })
1042 
1043 DEF_TRAVERSE_TYPELOC(VariableArrayType, {
1044  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1045  return TraverseArrayTypeLocHelper(TL);
1046 })
1047 
1048 DEF_TRAVERSE_TYPELOC(DependentSizedArrayType, {
1049  TRY_TO(TraverseTypeLoc(TL.getElementLoc()));
1050  return TraverseArrayTypeLocHelper(TL);
1051 })
1052 
1053 // FIXME: order? why not size expr first?
1054 // FIXME: base VectorTypeLoc is unfinished
1055 DEF_TRAVERSE_TYPELOC(DependentSizedExtVectorType, {
1056  if (TL.getTypePtr()->getSizeExpr())
1057  TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr()));
1058  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1059 })
1060 
1061 // FIXME: VectorTypeLoc is unfinished
1062 DEF_TRAVERSE_TYPELOC(VectorType, {
1063  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1064 })
1065 
1066 // FIXME: size and attributes
1067 // FIXME: base VectorTypeLoc is unfinished
1068 DEF_TRAVERSE_TYPELOC(ExtVectorType, {
1069  TRY_TO(TraverseType(TL.getTypePtr()->getElementType()));
1070 })
1071 
1072 DEF_TRAVERSE_TYPELOC(FunctionNoProtoType,
1073  { TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); })
1074 
1075 // FIXME: location of exception specifications (attributes?)
1076 DEF_TRAVERSE_TYPELOC(FunctionProtoType, {
1077  TRY_TO(TraverseTypeLoc(TL.getReturnLoc()));
1078 
1079  const FunctionProtoType *T = TL.getTypePtr();
1080 
1081  for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) {
1082  if (TL.getParam(I)) {
1083  TRY_TO(TraverseDecl(TL.getParam(I)));
1084  } else if (I < T->getNumParams()) {
1085  TRY_TO(TraverseType(T->getParamType(I)));
1086  }
1087  }
1088 
1089  for (const auto &E : T->exceptions()) {
1090  TRY_TO(TraverseType(E));
1091  }
1092 
1093  if (Expr *NE = T->getNoexceptExpr())
1094  TRY_TO(TraverseStmt(NE));
1095 })
1096 
1097 DEF_TRAVERSE_TYPELOC(UnresolvedUsingType, {})
1098 DEF_TRAVERSE_TYPELOC(TypedefType, {})
1099 
1100 DEF_TRAVERSE_TYPELOC(TypeOfExprType,
1101  { TRY_TO(TraverseStmt(TL.getUnderlyingExpr())); })
1102 
1103 DEF_TRAVERSE_TYPELOC(TypeOfType, {
1104  TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1105 })
1106 
1107 // FIXME: location of underlying expr
1108 DEF_TRAVERSE_TYPELOC(DecltypeType, {
1109  TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr()));
1110 })
1111 
1112 DEF_TRAVERSE_TYPELOC(UnaryTransformType, {
1113  TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
1114 })
1115 
1116 DEF_TRAVERSE_TYPELOC(AutoType, {
1117  TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
1118 })
1119 
1120 DEF_TRAVERSE_TYPELOC(RecordType, {})
1121 DEF_TRAVERSE_TYPELOC(EnumType, {})
1122 DEF_TRAVERSE_TYPELOC(TemplateTypeParmType, {})
1123 DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType, {})
1124 DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmPackType, {})
1125 
1126 // FIXME: use the loc for the template name?
1127 DEF_TRAVERSE_TYPELOC(TemplateSpecializationType, {
1128  TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));
1129  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1130  TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1131  }
1132 })
1133 
1134 DEF_TRAVERSE_TYPELOC(InjectedClassNameType, {})
1135 
1136 DEF_TRAVERSE_TYPELOC(ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); })
1137 
1138 DEF_TRAVERSE_TYPELOC(AttributedType,
1139  { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); })
1140 
1141 DEF_TRAVERSE_TYPELOC(ElaboratedType, {
1142  if (TL.getQualifierLoc()) {
1143  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1144  }
1145  TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc()));
1146 })
1147 
1148 DEF_TRAVERSE_TYPELOC(DependentNameType, {
1149  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1150 })
1151 
1152 DEF_TRAVERSE_TYPELOC(DependentTemplateSpecializationType, {
1153  if (TL.getQualifierLoc()) {
1154  TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc()));
1155  }
1156 
1157  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) {
1158  TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I)));
1159  }
1160 })
1161 
1162 DEF_TRAVERSE_TYPELOC(PackExpansionType,
1163  { TRY_TO(TraverseTypeLoc(TL.getPatternLoc())); })
1164 
1165 DEF_TRAVERSE_TYPELOC(ObjCInterfaceType, {})
1166 
1167 DEF_TRAVERSE_TYPELOC(ObjCObjectType, {
1168  // We have to watch out here because an ObjCInterfaceType's base
1169  // type is itself.
1170  if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr())
1171  TRY_TO(TraverseTypeLoc(TL.getBaseLoc()));
1172  for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i)
1173  TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc()));
1174 })
1175 
1176 DEF_TRAVERSE_TYPELOC(ObjCObjectPointerType,
1177  { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); })
1178 
1179 DEF_TRAVERSE_TYPELOC(AtomicType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc())); })
1180 
1181 #undef DEF_TRAVERSE_TYPELOC
1182 
1183 // ----------------- Decl traversal -----------------
1184 //
1185 // For a Decl, we automate (in the DEF_TRAVERSE_DECL macro) traversing
1186 // the children that come from the DeclContext associated with it.
1187 // Therefore each Traverse* only needs to worry about children other
1188 // than those.
1189 
1190 template <typename Derived>
1191 bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
1192  if (!DC)
1193  return true;
1194 
1195  for (auto *Child : DC->decls()) {
1196  // BlockDecls and CapturedDecls are traversed through BlockExprs and
1197  // CapturedStmts respectively.
1198  if (!isa<BlockDecl>(Child) && !isa<CapturedDecl>(Child))
1199  TRY_TO(TraverseDecl(Child));
1200  }
1201 
1202  return true;
1203 }
1204 
1205 // This macro makes available a variable D, the passed-in decl.
1206 #define DEF_TRAVERSE_DECL(DECL, CODE) \
1207  template <typename Derived> \
1208  bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) { \
1209  TRY_TO(WalkUpFrom##DECL(D)); \
1210  { CODE; } \
1211  TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D))); \
1212  return true; \
1213  }
1214 
1215 DEF_TRAVERSE_DECL(AccessSpecDecl, {})
1216 
1217 DEF_TRAVERSE_DECL(BlockDecl, {
1218  if (TypeSourceInfo *TInfo = D->getSignatureAsWritten())
1219  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
1220  TRY_TO(TraverseStmt(D->getBody()));
1221  for (const auto &I : D->captures()) {
1222  if (I.hasCopyExpr()) {
1223  TRY_TO(TraverseStmt(I.getCopyExpr()));
1224  }
1225  }
1226  // This return statement makes sure the traversal of nodes in
1227  // decls_begin()/decls_end() (done in the DEF_TRAVERSE_DECL macro)
1228  // is skipped - don't remove it.
1229  return true;
1230 })
1231 
1232 DEF_TRAVERSE_DECL(CapturedDecl, {
1233  TRY_TO(TraverseStmt(D->getBody()));
1234  // This return statement makes sure the traversal of nodes in
1235  // decls_begin()/decls_end() (done in the DEF_TRAVERSE_DECL macro)
1236  // is skipped - don't remove it.
1237  return true;
1238 })
1239 
1240 DEF_TRAVERSE_DECL(EmptyDecl, {})
1241 
1242 DEF_TRAVERSE_DECL(FileScopeAsmDecl,
1243  { TRY_TO(TraverseStmt(D->getAsmString())); })
1244 
1245 DEF_TRAVERSE_DECL(ImportDecl, {})
1246 
1247 DEF_TRAVERSE_DECL(FriendDecl, {
1248  // Friend is either decl or a type.
1249  if (D->getFriendType())
1250  TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1251  else
1252  TRY_TO(TraverseDecl(D->getFriendDecl()));
1253 })
1254 
1255 DEF_TRAVERSE_DECL(FriendTemplateDecl, {
1256  if (D->getFriendType())
1257  TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc()));
1258  else
1259  TRY_TO(TraverseDecl(D->getFriendDecl()));
1260  for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) {
1261  TemplateParameterList *TPL = D->getTemplateParameterList(I);
1262  for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end();
1263  ITPL != ETPL; ++ITPL) {
1264  TRY_TO(TraverseDecl(*ITPL));
1265  }
1266  }
1267 })
1268 
1269 DEF_TRAVERSE_DECL(ClassScopeFunctionSpecializationDecl,
1270  { TRY_TO(TraverseDecl(D->getSpecialization())); })
1271 
1272 DEF_TRAVERSE_DECL(LinkageSpecDecl, {})
1273 
1274 DEF_TRAVERSE_DECL(ObjCPropertyImplDecl, {// FIXME: implement this
1275  })
1276 
1277 DEF_TRAVERSE_DECL(StaticAssertDecl, {
1278  TRY_TO(TraverseStmt(D->getAssertExpr()));
1279  TRY_TO(TraverseStmt(D->getMessage()));
1280 })
1281 
1283  TranslationUnitDecl,
1284  {// Code in an unnamed namespace shows up automatically in
1285  // decls_begin()/decls_end(). Thus we don't need to recurse on
1286  // D->getAnonymousNamespace().
1287  })
1288 
1289 DEF_TRAVERSE_DECL(ExternCContextDecl, {})
1290 
1291 DEF_TRAVERSE_DECL(NamespaceAliasDecl, {
1292  // We shouldn't traverse an aliased namespace, since it will be
1293  // defined (and, therefore, traversed) somewhere else.
1294  //
1295  // This return statement makes sure the traversal of nodes in
1296  // decls_begin()/decls_end() (done in the DEF_TRAVERSE_DECL macro)
1297  // is skipped - don't remove it.
1298  return true;
1299 })
1300 
1301 DEF_TRAVERSE_DECL(LabelDecl, {// There is no code in a LabelDecl.
1302  })
1303 
1305  NamespaceDecl,
1306  {// Code in an unnamed namespace shows up automatically in
1307  // decls_begin()/decls_end(). Thus we don't need to recurse on
1308  // D->getAnonymousNamespace().
1309  })
1310 
1311 DEF_TRAVERSE_DECL(ObjCCompatibleAliasDecl, {// FIXME: implement
1312  })
1313 
1314 DEF_TRAVERSE_DECL(ObjCCategoryDecl, {// FIXME: implement
1315  if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) {
1316  for (auto typeParam : *typeParamList) {
1317  TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1318  }
1319  }
1320  return true;
1321 })
1322 
1323 DEF_TRAVERSE_DECL(ObjCCategoryImplDecl, {// FIXME: implement
1324  })
1325 
1326 DEF_TRAVERSE_DECL(ObjCImplementationDecl, {// FIXME: implement
1327  })
1328 
1329 DEF_TRAVERSE_DECL(ObjCInterfaceDecl, {// FIXME: implement
1330  if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) {
1331  for (auto typeParam : *typeParamList) {
1332  TRY_TO(TraverseObjCTypeParamDecl(typeParam));
1333  }
1334  }
1335 
1336  if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) {
1337  TRY_TO(TraverseTypeLoc(superTInfo->getTypeLoc()));
1338  }
1339 })
1340 
1341 DEF_TRAVERSE_DECL(ObjCProtocolDecl, {// FIXME: implement
1342  })
1343 
1344 DEF_TRAVERSE_DECL(ObjCMethodDecl, {
1345  if (D->getReturnTypeSourceInfo()) {
1346  TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc()));
1347  }
1348  for (ObjCMethodDecl::param_iterator I = D->param_begin(), E = D->param_end();
1349  I != E; ++I) {
1350  TRY_TO(TraverseDecl(*I));
1351  }
1352  if (D->isThisDeclarationADefinition()) {
1353  TRY_TO(TraverseStmt(D->getBody()));
1354  }
1355  return true;
1356 })
1357 
1358 DEF_TRAVERSE_DECL(ObjCTypeParamDecl, {
1359  if (D->hasExplicitBound()) {
1360  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1361  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1362  // declaring the type alias, not something that was written in the
1363  // source.
1364  }
1365 })
1366 
1367 DEF_TRAVERSE_DECL(ObjCPropertyDecl, {
1368  if (D->getTypeSourceInfo())
1369  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1370  else
1371  TRY_TO(TraverseType(D->getType()));
1372  return true;
1373 })
1374 
1375 DEF_TRAVERSE_DECL(UsingDecl, {
1376  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1377  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1378 })
1379 
1380 DEF_TRAVERSE_DECL(UsingDirectiveDecl, {
1381  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1382 })
1383 
1384 DEF_TRAVERSE_DECL(UsingShadowDecl, {})
1385 
1386 DEF_TRAVERSE_DECL(OMPThreadPrivateDecl, {
1387  for (auto *I : D->varlists()) {
1388  TRY_TO(TraverseStmt(I));
1389  }
1390 })
1391 
1392 // A helper method for TemplateDecl's children.
1393 template <typename Derived>
1394 bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
1395  TemplateParameterList *TPL) {
1396  if (TPL) {
1397  for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
1398  I != E; ++I) {
1399  TRY_TO(TraverseDecl(*I));
1400  }
1401  }
1402  return true;
1403 }
1404 
1405 // A helper method for traversing the implicit instantiations of a
1406 // class template.
1407 template <typename Derived>
1408 bool RecursiveASTVisitor<Derived>::TraverseClassInstantiations(
1409  ClassTemplateDecl *D) {
1410  for (auto *SD : D->specializations()) {
1411  for (auto *RD : SD->redecls()) {
1412  // We don't want to visit injected-class-names in this traversal.
1413  if (cast<CXXRecordDecl>(RD)->isInjectedClassName())
1414  continue;
1415 
1416  switch (
1417  cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1418  // Visit the implicit instantiations with the requested pattern.
1419  case TSK_Undeclared:
1421  TRY_TO(TraverseDecl(RD));
1422  break;
1423 
1424  // We don't need to do anything on an explicit instantiation
1425  // or explicit specialization because there will be an explicit
1426  // node for it elsewhere.
1430  break;
1431  }
1432  }
1433  }
1434 
1435  return true;
1436 }
1437 
1438 DEF_TRAVERSE_DECL(ClassTemplateDecl, {
1439  CXXRecordDecl *TempDecl = D->getTemplatedDecl();
1440  TRY_TO(TraverseDecl(TempDecl));
1441  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1442 
1443  // By default, we do not traverse the instantiations of
1444  // class templates since they do not appear in the user code. The
1445  // following code optionally traverses them.
1446  //
1447  // We only traverse the class instantiations when we see the canonical
1448  // declaration of the template, to ensure we only visit them once.
1449  if (getDerived().shouldVisitTemplateInstantiations() &&
1450  D == D->getCanonicalDecl())
1451  TRY_TO(TraverseClassInstantiations(D));
1452 
1453  // Note that getInstantiatedFromMemberTemplate() is just a link
1454  // from a template instantiation back to the template from which
1455  // it was instantiated, and thus should not be traversed.
1456 })
1457 
1458 // A helper method for traversing the implicit instantiations of a
1459 // class template.
1460 template <typename Derived>
1461 bool RecursiveASTVisitor<Derived>::TraverseVariableInstantiations(
1462  VarTemplateDecl *D) {
1463  for (auto *SD : D->specializations()) {
1464  for (auto *RD : SD->redecls()) {
1465  switch (
1466  cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
1467  // Visit the implicit instantiations with the requested pattern.
1468  case TSK_Undeclared:
1470  TRY_TO(TraverseDecl(RD));
1471  break;
1472 
1473  // We don't need to do anything on an explicit instantiation
1474  // or explicit specialization because there will be an explicit
1475  // node for it elsewhere.
1479  break;
1480  }
1481  }
1482  }
1483 
1484  return true;
1485 }
1486 
1487 DEF_TRAVERSE_DECL(VarTemplateDecl, {
1488  VarDecl *TempDecl = D->getTemplatedDecl();
1489  TRY_TO(TraverseDecl(TempDecl));
1490  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1491 
1492  // By default, we do not traverse the instantiations of
1493  // variable templates since they do not appear in the user code. The
1494  // following code optionally traverses them.
1495  //
1496  // We only traverse the variable instantiations when we see the canonical
1497  // declaration of the template, to ensure we only visit them once.
1498  if (getDerived().shouldVisitTemplateInstantiations() &&
1499  D == D->getCanonicalDecl())
1500  TRY_TO(TraverseVariableInstantiations(D));
1501 
1502  // Note that getInstantiatedFromMemberTemplate() is just a link
1503  // from a template instantiation back to the template from which
1504  // it was instantiated, and thus should not be traversed.
1505 })
1506 
1507 // A helper method for traversing the instantiations of a
1508 // function while skipping its specializations.
1509 template <typename Derived>
1510 bool RecursiveASTVisitor<Derived>::TraverseFunctionInstantiations(
1511  FunctionTemplateDecl *D) {
1512  for (auto *FD : D->specializations()) {
1513  for (auto *RD : FD->redecls()) {
1514  switch (RD->getTemplateSpecializationKind()) {
1515  case TSK_Undeclared:
1517  // We don't know what kind of FunctionDecl this is.
1518  TRY_TO(TraverseDecl(RD));
1519  break;
1520 
1521  // No need to visit explicit instantiations, we'll find the node
1522  // eventually.
1523  // FIXME: This is incorrect; there is no other node for an explicit
1524  // instantiation of a function template specialization.
1527  break;
1528 
1530  break;
1531  }
1532  }
1533  }
1534 
1535  return true;
1536 }
1537 
1538 DEF_TRAVERSE_DECL(FunctionTemplateDecl, {
1539  TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1540  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1541 
1542  // By default, we do not traverse the instantiations of
1543  // function templates since they do not appear in the user code. The
1544  // following code optionally traverses them.
1545  //
1546  // We only traverse the function instantiations when we see the canonical
1547  // declaration of the template, to ensure we only visit them once.
1548  if (getDerived().shouldVisitTemplateInstantiations() &&
1549  D == D->getCanonicalDecl())
1550  TRY_TO(TraverseFunctionInstantiations(D));
1551 })
1552 
1553 DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, {
1554  // D is the "T" in something like
1555  // template <template <typename> class T> class container { };
1556  TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1557  if (D->hasDefaultArgument()) {
1558  TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument()));
1559  }
1560  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1561 })
1562 
1563 DEF_TRAVERSE_DECL(TemplateTypeParmDecl, {
1564  // D is the "T" in something like "template<typename T> class vector;"
1565  if (D->getTypeForDecl())
1566  TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
1567  if (D->hasDefaultArgument())
1568  TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc()));
1569 })
1570 
1571 DEF_TRAVERSE_DECL(TypedefDecl, {
1572  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1573  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1574  // declaring the typedef, not something that was written in the
1575  // source.
1576 })
1577 
1578 DEF_TRAVERSE_DECL(TypeAliasDecl, {
1579  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1580  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1581  // declaring the type alias, not something that was written in the
1582  // source.
1583 })
1584 
1585 DEF_TRAVERSE_DECL(TypeAliasTemplateDecl, {
1586  TRY_TO(TraverseDecl(D->getTemplatedDecl()));
1587  TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters()));
1588 })
1589 
1590 DEF_TRAVERSE_DECL(UnresolvedUsingTypenameDecl, {
1591  // A dependent using declaration which was marked with 'typename'.
1592  // template<class T> class A : public B<T> { using typename B<T>::foo; };
1593  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1594  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1595  // declaring the type, not something that was written in the
1596  // source.
1597 })
1598 
1599 DEF_TRAVERSE_DECL(EnumDecl, {
1600  if (D->getTypeForDecl())
1601  TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
1602 
1603  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1604  // The enumerators are already traversed by
1605  // decls_begin()/decls_end().
1606 })
1607 
1608 // Helper methods for RecordDecl and its children.
1609 template <typename Derived>
1610 bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
1611  // We shouldn't traverse D->getTypeForDecl(); it's a result of
1612  // declaring the type, not something that was written in the source.
1613 
1614  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1615  return true;
1616 }
1617 
1618 template <typename Derived>
1619 bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) {
1620  if (!TraverseRecordHelper(D))
1621  return false;
1622  if (D->isCompleteDefinition()) {
1623  for (const auto &I : D->bases()) {
1624  TRY_TO(TraverseTypeLoc(I.getTypeSourceInfo()->getTypeLoc()));
1625  }
1626  // We don't traverse the friends or the conversions, as they are
1627  // already in decls_begin()/decls_end().
1628  }
1629  return true;
1630 }
1631 
1632 DEF_TRAVERSE_DECL(RecordDecl, { TRY_TO(TraverseRecordHelper(D)); })
1633 
1634 DEF_TRAVERSE_DECL(CXXRecordDecl, { TRY_TO(TraverseCXXRecordHelper(D)); })
1635 
1636 DEF_TRAVERSE_DECL(ClassTemplateSpecializationDecl, {
1637  // For implicit instantiations ("set<int> x;"), we don't want to
1638  // recurse at all, since the instatiated class isn't written in
1639  // the source code anywhere. (Note the instatiated *type* --
1640  // set<int> -- is written, and will still get a callback of
1641  // TemplateSpecializationType). For explicit instantiations
1642  // ("template set<int>;"), we do need a callback, since this
1643  // is the only callback that's made for this instantiation.
1644  // We use getTypeAsWritten() to distinguish.
1645  if (TypeSourceInfo *TSI = D->getTypeAsWritten())
1646  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
1647 
1648  if (!getDerived().shouldVisitTemplateInstantiations() &&
1649  D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
1650  // Returning from here skips traversing the
1651  // declaration context of the ClassTemplateSpecializationDecl
1652  // (embedded in the DEF_TRAVERSE_DECL() macro)
1653  // which contains the instantiated members of the class.
1654  return true;
1655 })
1656 
1657 template <typename Derived>
1658 bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
1659  const TemplateArgumentLoc *TAL, unsigned Count) {
1660  for (unsigned I = 0; I < Count; ++I) {
1661  TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));
1662  }
1663  return true;
1664 }
1665 
1666 DEF_TRAVERSE_DECL(ClassTemplatePartialSpecializationDecl, {
1667  // The partial specialization.
1668  if (TemplateParameterList *TPL = D->getTemplateParameters()) {
1669  for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
1670  I != E; ++I) {
1671  TRY_TO(TraverseDecl(*I));
1672  }
1673  }
1674  // The args that remains unspecialized.
1675  TRY_TO(TraverseTemplateArgumentLocsHelper(
1676  D->getTemplateArgsAsWritten()->getTemplateArgs(),
1677  D->getTemplateArgsAsWritten()->NumTemplateArgs));
1678 
1679  // Don't need the ClassTemplatePartialSpecializationHelper, even
1680  // though that's our parent class -- we already visit all the
1681  // template args here.
1682  TRY_TO(TraverseCXXRecordHelper(D));
1683 
1684  // Instantiations will have been visited with the primary template.
1685 })
1686 
1687 DEF_TRAVERSE_DECL(EnumConstantDecl, { TRY_TO(TraverseStmt(D->getInitExpr())); })
1688 
1689 DEF_TRAVERSE_DECL(UnresolvedUsingValueDecl, {
1690  // Like UnresolvedUsingTypenameDecl, but without the 'typename':
1691  // template <class T> Class A : public Base<T> { using Base<T>::foo; };
1692  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1693  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1694 })
1695 
1696 DEF_TRAVERSE_DECL(IndirectFieldDecl, {})
1697 
1698 template <typename Derived>
1699 bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
1700  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1701  if (D->getTypeSourceInfo())
1702  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1703  else
1704  TRY_TO(TraverseType(D->getType()));
1705  return true;
1706 }
1707 
1708 DEF_TRAVERSE_DECL(MSPropertyDecl, { TRY_TO(TraverseDeclaratorHelper(D)); })
1709 
1710 DEF_TRAVERSE_DECL(FieldDecl, {
1711  TRY_TO(TraverseDeclaratorHelper(D));
1712  if (D->isBitField())
1713  TRY_TO(TraverseStmt(D->getBitWidth()));
1714  else if (D->hasInClassInitializer())
1715  TRY_TO(TraverseStmt(D->getInClassInitializer()));
1716 })
1717 
1718 DEF_TRAVERSE_DECL(ObjCAtDefsFieldDecl, {
1719  TRY_TO(TraverseDeclaratorHelper(D));
1720  if (D->isBitField())
1721  TRY_TO(TraverseStmt(D->getBitWidth()));
1722  // FIXME: implement the rest.
1723 })
1724 
1725 DEF_TRAVERSE_DECL(ObjCIvarDecl, {
1726  TRY_TO(TraverseDeclaratorHelper(D));
1727  if (D->isBitField())
1728  TRY_TO(TraverseStmt(D->getBitWidth()));
1729  // FIXME: implement the rest.
1730 })
1731 
1732 template <typename Derived>
1733 bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
1734  TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
1735  TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
1736 
1737  // If we're an explicit template specialization, iterate over the
1738  // template args that were explicitly specified. If we were doing
1739  // this in typing order, we'd do it between the return type and
1740  // the function args, but both are handled by the FunctionTypeLoc
1741  // above, so we have to choose one side. I've decided to do before.
1742  if (const FunctionTemplateSpecializationInfo *FTSI =
1743  D->getTemplateSpecializationInfo()) {
1744  if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared &&
1745  FTSI->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) {
1746  // A specialization might not have explicit template arguments if it has
1747  // a templated return type and concrete arguments.
1748  if (const ASTTemplateArgumentListInfo *TALI =
1749  FTSI->TemplateArgumentsAsWritten) {
1750  TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(),
1751  TALI->NumTemplateArgs));
1752  }
1753  }
1754  }
1755 
1756  // Visit the function type itself, which can be either
1757  // FunctionNoProtoType or FunctionProtoType, or a typedef. This
1758  // also covers the return type and the function parameters,
1759  // including exception specifications.
1760  TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
1761 
1762  if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) {
1763  // Constructor initializers.
1764  for (auto *I : Ctor->inits()) {
1765  TRY_TO(TraverseConstructorInitializer(I));
1766  }
1767  }
1768 
1769  if (D->isThisDeclarationADefinition()) {
1770  TRY_TO(TraverseStmt(D->getBody())); // Function body.
1771  }
1772  return true;
1773 }
1774 
1775 DEF_TRAVERSE_DECL(FunctionDecl, {
1776  // We skip decls_begin/decls_end, which are already covered by
1777  // TraverseFunctionHelper().
1778  return TraverseFunctionHelper(D);
1779 })
1780 
1781 DEF_TRAVERSE_DECL(CXXMethodDecl, {
1782  // We skip decls_begin/decls_end, which are already covered by
1783  // TraverseFunctionHelper().
1784  return TraverseFunctionHelper(D);
1785 })
1786 
1787 DEF_TRAVERSE_DECL(CXXConstructorDecl, {
1788  // We skip decls_begin/decls_end, which are already covered by
1789  // TraverseFunctionHelper().
1790  return TraverseFunctionHelper(D);
1791 })
1792 
1793 // CXXConversionDecl is the declaration of a type conversion operator.
1794 // It's not a cast expression.
1795 DEF_TRAVERSE_DECL(CXXConversionDecl, {
1796  // We skip decls_begin/decls_end, which are already covered by
1797  // TraverseFunctionHelper().
1798  return TraverseFunctionHelper(D);
1799 })
1800 
1801 DEF_TRAVERSE_DECL(CXXDestructorDecl, {
1802  // We skip decls_begin/decls_end, which are already covered by
1803  // TraverseFunctionHelper().
1804  return TraverseFunctionHelper(D);
1805 })
1806 
1807 template <typename Derived>
1808 bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
1809  TRY_TO(TraverseDeclaratorHelper(D));
1810  // Default params are taken care of when we traverse the ParmVarDecl.
1811  if (!isa<ParmVarDecl>(D))
1812  TRY_TO(TraverseStmt(D->getInit()));
1813  return true;
1814 }
1815 
1816 DEF_TRAVERSE_DECL(VarDecl, { TRY_TO(TraverseVarHelper(D)); })
1817 
1818 DEF_TRAVERSE_DECL(VarTemplateSpecializationDecl, {
1819  // For implicit instantiations, we don't want to
1820  // recurse at all, since the instatiated class isn't written in
1821  // the source code anywhere.
1822  if (TypeSourceInfo *TSI = D->getTypeAsWritten())
1823  TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
1824 
1825  if (!getDerived().shouldVisitTemplateInstantiations() &&
1826  D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
1827  // Returning from here skips traversing the
1828  // declaration context of the VarTemplateSpecializationDecl
1829  // (embedded in the DEF_TRAVERSE_DECL() macro).
1830  return true;
1831 })
1832 
1833 DEF_TRAVERSE_DECL(VarTemplatePartialSpecializationDecl, {
1834  // The partial specialization.
1835  if (TemplateParameterList *TPL = D->getTemplateParameters()) {
1836  for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
1837  I != E; ++I) {
1838  TRY_TO(TraverseDecl(*I));
1839  }
1840  }
1841  // The args that remains unspecialized.
1842  TRY_TO(TraverseTemplateArgumentLocsHelper(
1843  D->getTemplateArgsAsWritten()->getTemplateArgs(),
1844  D->getTemplateArgsAsWritten()->NumTemplateArgs));
1845 
1846  // Don't need the VarTemplatePartialSpecializationHelper, even
1847  // though that's our parent class -- we already visit all the
1848  // template args here.
1849  TRY_TO(TraverseVarHelper(D));
1850 
1851  // Instantiations will have been visited with the primary
1852  // template.
1853 })
1854 
1855 DEF_TRAVERSE_DECL(ImplicitParamDecl, { TRY_TO(TraverseVarHelper(D)); })
1856 
1857 DEF_TRAVERSE_DECL(NonTypeTemplateParmDecl, {
1858  // A non-type template parameter, e.g. "S" in template<int S> class Foo ...
1859  TRY_TO(TraverseDeclaratorHelper(D));
1860  TRY_TO(TraverseStmt(D->getDefaultArgument()));
1861 })
1862 
1863 DEF_TRAVERSE_DECL(ParmVarDecl, {
1864  TRY_TO(TraverseVarHelper(D));
1865 
1866  if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() &&
1867  !D->hasUnparsedDefaultArg())
1868  TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg()));
1869 
1870  if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() &&
1871  !D->hasUnparsedDefaultArg())
1872  TRY_TO(TraverseStmt(D->getDefaultArg()));
1873 })
1874 
1875 #undef DEF_TRAVERSE_DECL
1876 
1877 // ----------------- Stmt traversal -----------------
1878 //
1879 // For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating
1880 // over the children defined in children() (every stmt defines these,
1881 // though sometimes the range is empty). Each individual Traverse*
1882 // method only needs to worry about children other than those. To see
1883 // what children() does for a given class, see, e.g.,
1884 // http://clang.llvm.org/doxygen/Stmt_8cpp_source.html
1885 
1886 // This macro makes available a variable S, the passed-in stmt.
1887 #define DEF_TRAVERSE_STMT(STMT, CODE) \
1888  template <typename Derived> \
1889  bool RecursiveASTVisitor<Derived>::Traverse##STMT(STMT *S) { \
1890  TRY_TO(WalkUpFrom##STMT(S)); \
1891  StmtQueueAction StmtQueue(*this); \
1892  { CODE; } \
1893  for (Stmt *SubStmt : S->children()) { \
1894  StmtQueue.queue(SubStmt); \
1895  } \
1896  return true; \
1897  }
1898 
1899 DEF_TRAVERSE_STMT(GCCAsmStmt, {
1900  StmtQueue.queue(S->getAsmString());
1901  for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) {
1902  StmtQueue.queue(S->getInputConstraintLiteral(I));
1903  }
1904  for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) {
1905  StmtQueue.queue(S->getOutputConstraintLiteral(I));
1906  }
1907  for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) {
1908  StmtQueue.queue(S->getClobberStringLiteral(I));
1909  }
1910  // children() iterates over inputExpr and outputExpr.
1911 })
1912 
1914  MSAsmStmt,
1915  {// FIXME: MS Asm doesn't currently parse Constraints, Clobbers, etc. Once
1916  // added this needs to be implemented.
1917  })
1918 
1919 DEF_TRAVERSE_STMT(CXXCatchStmt, {
1920  TRY_TO(TraverseDecl(S->getExceptionDecl()));
1921  // children() iterates over the handler block.
1922 })
1923 
1924 DEF_TRAVERSE_STMT(DeclStmt, {
1925  for (auto *I : S->decls()) {
1926  TRY_TO(TraverseDecl(I));
1927  }
1928  // Suppress the default iteration over children() by
1929  // returning. Here's why: A DeclStmt looks like 'type var [=
1930  // initializer]'. The decls above already traverse over the
1931  // initializers, so we don't have to do it again (which
1932  // children() would do).
1933  return true;
1934 })
1935 
1936 // These non-expr stmts (most of them), do not need any action except
1937 // iterating over the children.
1938 DEF_TRAVERSE_STMT(BreakStmt, {})
1939 DEF_TRAVERSE_STMT(CXXTryStmt, {})
1940 DEF_TRAVERSE_STMT(CaseStmt, {})
1941 DEF_TRAVERSE_STMT(CompoundStmt, {})
1942 DEF_TRAVERSE_STMT(ContinueStmt, {})
1943 DEF_TRAVERSE_STMT(DefaultStmt, {})
1944 DEF_TRAVERSE_STMT(DoStmt, {})
1945 DEF_TRAVERSE_STMT(ForStmt, {})
1946 DEF_TRAVERSE_STMT(GotoStmt, {})
1947 DEF_TRAVERSE_STMT(IfStmt, {})
1948 DEF_TRAVERSE_STMT(IndirectGotoStmt, {})
1949 DEF_TRAVERSE_STMT(LabelStmt, {})
1950 DEF_TRAVERSE_STMT(AttributedStmt, {})
1951 DEF_TRAVERSE_STMT(NullStmt, {})
1952 DEF_TRAVERSE_STMT(ObjCAtCatchStmt, {})
1953 DEF_TRAVERSE_STMT(ObjCAtFinallyStmt, {})
1954 DEF_TRAVERSE_STMT(ObjCAtSynchronizedStmt, {})
1955 DEF_TRAVERSE_STMT(ObjCAtThrowStmt, {})
1956 DEF_TRAVERSE_STMT(ObjCAtTryStmt, {})
1957 DEF_TRAVERSE_STMT(ObjCForCollectionStmt, {})
1958 DEF_TRAVERSE_STMT(ObjCAutoreleasePoolStmt, {})
1959 DEF_TRAVERSE_STMT(CXXForRangeStmt, {})
1960 DEF_TRAVERSE_STMT(MSDependentExistsStmt, {
1961  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1962  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
1963 })
1964 DEF_TRAVERSE_STMT(ReturnStmt, {})
1965 DEF_TRAVERSE_STMT(SwitchStmt, {})
1966 DEF_TRAVERSE_STMT(WhileStmt, {})
1967 
1968 DEF_TRAVERSE_STMT(CXXDependentScopeMemberExpr, {
1969  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1970  TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
1971  if (S->hasExplicitTemplateArgs()) {
1972  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
1973  S->getNumTemplateArgs()));
1974  }
1975 })
1976 
1977 DEF_TRAVERSE_STMT(DeclRefExpr, {
1978  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1979  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
1980  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
1981  S->getNumTemplateArgs()));
1982 })
1983 
1984 DEF_TRAVERSE_STMT(DependentScopeDeclRefExpr, {
1985  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1986  TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo()));
1987  if (S->hasExplicitTemplateArgs()) {
1988  TRY_TO(TraverseTemplateArgumentLocsHelper(
1989  S->getExplicitTemplateArgs().getTemplateArgs(),
1990  S->getNumTemplateArgs()));
1991  }
1992 })
1993 
1994 DEF_TRAVERSE_STMT(MemberExpr, {
1995  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
1996  TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo()));
1997  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
1998  S->getNumTemplateArgs()));
1999 })
2000 
2002  ImplicitCastExpr,
2003  {// We don't traverse the cast type, as it's not written in the
2004  // source code.
2005  })
2006 
2007 DEF_TRAVERSE_STMT(CStyleCastExpr, {
2008  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2009 })
2010 
2011 DEF_TRAVERSE_STMT(CXXFunctionalCastExpr, {
2012  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2013 })
2014 
2015 DEF_TRAVERSE_STMT(CXXConstCastExpr, {
2016  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2017 })
2018 
2019 DEF_TRAVERSE_STMT(CXXDynamicCastExpr, {
2020  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2021 })
2022 
2023 DEF_TRAVERSE_STMT(CXXReinterpretCastExpr, {
2024  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2025 })
2026 
2027 DEF_TRAVERSE_STMT(CXXStaticCastExpr, {
2028  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2029 })
2030 
2031 // InitListExpr is a tricky one, because we want to do all our work on
2032 // the syntactic form of the listexpr, but this method takes the
2033 // semantic form by default. We can't use the macro helper because it
2034 // calls WalkUp*() on the semantic form, before our code can convert
2035 // to the syntactic form.
2036 template <typename Derived>
2037 bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) {
2038  if (InitListExpr *Syn = S->getSyntacticForm())
2039  S = Syn;
2040  TRY_TO(WalkUpFromInitListExpr(S));
2041  StmtQueueAction StmtQueue(*this);
2042  // All we need are the default actions. FIXME: use a helper function.
2043  for (Stmt *SubStmt : S->children()) {
2044  StmtQueue.queue(SubStmt);
2045  }
2046  return true;
2047 }
2048 
2049 // GenericSelectionExpr is a special case because the types and expressions
2050 // are interleaved. We also need to watch out for null types (default
2051 // generic associations).
2052 template <typename Derived>
2053 bool RecursiveASTVisitor<Derived>::TraverseGenericSelectionExpr(
2054  GenericSelectionExpr *S) {
2055  TRY_TO(WalkUpFromGenericSelectionExpr(S));
2056  StmtQueueAction StmtQueue(*this);
2057  StmtQueue.queue(S->getControllingExpr());
2058  for (unsigned i = 0; i != S->getNumAssocs(); ++i) {
2059  if (TypeSourceInfo *TS = S->getAssocTypeSourceInfo(i))
2060  TRY_TO(TraverseTypeLoc(TS->getTypeLoc()));
2061  StmtQueue.queue(S->getAssocExpr(i));
2062  }
2063  return true;
2064 }
2065 
2066 // PseudoObjectExpr is a special case because of the wierdness with
2067 // syntactic expressions and opaque values.
2068 template <typename Derived>
2069 bool
2070 RecursiveASTVisitor<Derived>::TraversePseudoObjectExpr(PseudoObjectExpr *S) {
2071  TRY_TO(WalkUpFromPseudoObjectExpr(S));
2072  StmtQueueAction StmtQueue(*this);
2073  StmtQueue.queue(S->getSyntacticForm());
2074  for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(),
2075  e = S->semantics_end();
2076  i != e; ++i) {
2077  Expr *sub = *i;
2078  if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub))
2079  sub = OVE->getSourceExpr();
2080  StmtQueue.queue(sub);
2081  }
2082  return true;
2083 }
2084 
2085 DEF_TRAVERSE_STMT(CXXScalarValueInitExpr, {
2086  // This is called for code like 'return T()' where T is a built-in
2087  // (i.e. non-class) type.
2088  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2089 })
2090 
2091 DEF_TRAVERSE_STMT(CXXNewExpr, {
2092  // The child-iterator will pick up the other arguments.
2093  TRY_TO(TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc()));
2094 })
2095 
2096 DEF_TRAVERSE_STMT(OffsetOfExpr, {
2097  // The child-iterator will pick up the expression representing
2098  // the field.
2099  // FIMXE: for code like offsetof(Foo, a.b.c), should we get
2100  // making a MemberExpr callbacks for Foo.a, Foo.a.b, and Foo.a.b.c?
2101  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2102 })
2103 
2104 DEF_TRAVERSE_STMT(UnaryExprOrTypeTraitExpr, {
2105  // The child-iterator will pick up the arg if it's an expression,
2106  // but not if it's a type.
2107  if (S->isArgumentType())
2108  TRY_TO(TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc()));
2109 })
2110 
2111 DEF_TRAVERSE_STMT(CXXTypeidExpr, {
2112  // The child-iterator will pick up the arg if it's an expression,
2113  // but not if it's a type.
2114  if (S->isTypeOperand())
2115  TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2116 })
2117 
2118 DEF_TRAVERSE_STMT(MSPropertyRefExpr, {
2119  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2120 })
2121 
2122 DEF_TRAVERSE_STMT(CXXUuidofExpr, {
2123  // The child-iterator will pick up the arg if it's an expression,
2124  // but not if it's a type.
2125  if (S->isTypeOperand())
2126  TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc()));
2127 })
2128 
2129 DEF_TRAVERSE_STMT(TypeTraitExpr, {
2130  for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2131  TRY_TO(TraverseTypeLoc(S->getArg(I)->getTypeLoc()));
2132 })
2133 
2134 DEF_TRAVERSE_STMT(ArrayTypeTraitExpr, {
2135  TRY_TO(TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc()));
2136 })
2137 
2138 DEF_TRAVERSE_STMT(ExpressionTraitExpr,
2139  { StmtQueue.queue(S->getQueriedExpression()); })
2140 
2141 DEF_TRAVERSE_STMT(VAArgExpr, {
2142  // The child-iterator will pick up the expression argument.
2143  TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc()));
2144 })
2145 
2146 DEF_TRAVERSE_STMT(CXXTemporaryObjectExpr, {
2147  // This is called for code like 'return T()' where T is a class type.
2148  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2149 })
2150 
2151 // Walk only the visible parts of lambda expressions.
2152 template <typename Derived>
2153 bool RecursiveASTVisitor<Derived>::TraverseLambdaExpr(LambdaExpr *S) {
2154  TRY_TO(WalkUpFromLambdaExpr(S));
2155 
2156  for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
2157  CEnd = S->explicit_capture_end();
2158  C != CEnd; ++C) {
2159  TRY_TO(TraverseLambdaCapture(S, C));
2160  }
2161 
2162  TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc();
2163  FunctionProtoTypeLoc Proto = TL.castAs<FunctionProtoTypeLoc>();
2164 
2165  if (S->hasExplicitParameters() && S->hasExplicitResultType()) {
2166  // Visit the whole type.
2167  TRY_TO(TraverseTypeLoc(TL));
2168  } else {
2169  if (S->hasExplicitParameters()) {
2170  // Visit parameters.
2171  for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) {
2172  TRY_TO(TraverseDecl(Proto.getParam(I)));
2173  }
2174  } else if (S->hasExplicitResultType()) {
2175  TRY_TO(TraverseTypeLoc(Proto.getReturnLoc()));
2176  }
2177 
2178  auto *T = Proto.getTypePtr();
2179  for (const auto &E : T->exceptions()) {
2180  TRY_TO(TraverseType(E));
2181  }
2182 
2183  if (Expr *NE = T->getNoexceptExpr())
2184  TRY_TO(TraverseStmt(NE));
2185  }
2186 
2187  TRY_TO(TraverseLambdaBody(S));
2188  return true;
2189 }
2190 
2191 DEF_TRAVERSE_STMT(CXXUnresolvedConstructExpr, {
2192  // This is called for code like 'T()', where T is a template argument.
2193  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2194 })
2195 
2196 // These expressions all might take explicit template arguments.
2197 // We traverse those if so. FIXME: implement these.
2198 DEF_TRAVERSE_STMT(CXXConstructExpr, {})
2199 DEF_TRAVERSE_STMT(CallExpr, {})
2200 DEF_TRAVERSE_STMT(CXXMemberCallExpr, {})
2201 
2202 // These exprs (most of them), do not need any action except iterating
2203 // over the children.
2204 DEF_TRAVERSE_STMT(AddrLabelExpr, {})
2205 DEF_TRAVERSE_STMT(ArraySubscriptExpr, {})
2206 DEF_TRAVERSE_STMT(BlockExpr, {
2207  TRY_TO(TraverseDecl(S->getBlockDecl()));
2208  return true; // no child statements to loop through.
2209 })
2210 DEF_TRAVERSE_STMT(ChooseExpr, {})
2211 DEF_TRAVERSE_STMT(CompoundLiteralExpr, {
2212  TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
2213 })
2214 DEF_TRAVERSE_STMT(CXXBindTemporaryExpr, {})
2215 DEF_TRAVERSE_STMT(CXXBoolLiteralExpr, {})
2216 DEF_TRAVERSE_STMT(CXXDefaultArgExpr, {})
2217 DEF_TRAVERSE_STMT(CXXDefaultInitExpr, {})
2218 DEF_TRAVERSE_STMT(CXXDeleteExpr, {})
2219 DEF_TRAVERSE_STMT(ExprWithCleanups, {})
2220 DEF_TRAVERSE_STMT(CXXNullPtrLiteralExpr, {})
2221 DEF_TRAVERSE_STMT(CXXStdInitializerListExpr, {})
2222 DEF_TRAVERSE_STMT(CXXPseudoDestructorExpr, {
2223  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2224  if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())
2225  TRY_TO(TraverseTypeLoc(ScopeInfo->getTypeLoc()));
2226  if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo())
2227  TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc()));
2228 })
2229 DEF_TRAVERSE_STMT(CXXThisExpr, {})
2230 DEF_TRAVERSE_STMT(CXXThrowExpr, {})
2231 DEF_TRAVERSE_STMT(UserDefinedLiteral, {})
2232 DEF_TRAVERSE_STMT(DesignatedInitExpr, {})
2233 DEF_TRAVERSE_STMT(DesignatedInitUpdateExpr, {})
2234 DEF_TRAVERSE_STMT(ExtVectorElementExpr, {})
2235 DEF_TRAVERSE_STMT(GNUNullExpr, {})
2236 DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {})
2237 DEF_TRAVERSE_STMT(NoInitExpr, {})
2238 DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {})
2239 DEF_TRAVERSE_STMT(ObjCEncodeExpr, {
2240  if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo())
2241  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2242 })
2243 DEF_TRAVERSE_STMT(ObjCIsaExpr, {})
2244 DEF_TRAVERSE_STMT(ObjCIvarRefExpr, {})
2245 DEF_TRAVERSE_STMT(ObjCMessageExpr, {
2246  if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo())
2247  TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
2248 })
2249 DEF_TRAVERSE_STMT(ObjCPropertyRefExpr, {})
2250 DEF_TRAVERSE_STMT(ObjCSubscriptRefExpr, {})
2251 DEF_TRAVERSE_STMT(ObjCProtocolExpr, {})
2252 DEF_TRAVERSE_STMT(ObjCSelectorExpr, {})
2253 DEF_TRAVERSE_STMT(ObjCIndirectCopyRestoreExpr, {})
2254 DEF_TRAVERSE_STMT(ObjCBridgedCastExpr, {
2255  TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
2256 })
2257 DEF_TRAVERSE_STMT(ParenExpr, {})
2258 DEF_TRAVERSE_STMT(ParenListExpr, {})
2259 DEF_TRAVERSE_STMT(PredefinedExpr, {})
2260 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
2261 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
2262 DEF_TRAVERSE_STMT(StmtExpr, {})
2263 DEF_TRAVERSE_STMT(UnresolvedLookupExpr, {
2264  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2265  if (S->hasExplicitTemplateArgs()) {
2266  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2267  S->getNumTemplateArgs()));
2268  }
2269 })
2270 
2271 DEF_TRAVERSE_STMT(UnresolvedMemberExpr, {
2272  TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
2273  if (S->hasExplicitTemplateArgs()) {
2274  TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
2275  S->getNumTemplateArgs()));
2276  }
2277 })
2278 
2279 DEF_TRAVERSE_STMT(SEHTryStmt, {})
2280 DEF_TRAVERSE_STMT(SEHExceptStmt, {})
2281 DEF_TRAVERSE_STMT(SEHFinallyStmt, {})
2282 DEF_TRAVERSE_STMT(SEHLeaveStmt, {})
2283 DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); })
2284 
2285 DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {})
2286 DEF_TRAVERSE_STMT(OpaqueValueExpr, {})
2287 DEF_TRAVERSE_STMT(TypoExpr, {})
2289 
2290 // These operators (all of them) do not need any action except
2291 // iterating over the children.
2292 DEF_TRAVERSE_STMT(BinaryConditionalOperator, {})
2293 DEF_TRAVERSE_STMT(ConditionalOperator, {})
2294 DEF_TRAVERSE_STMT(UnaryOperator, {})
2295 DEF_TRAVERSE_STMT(BinaryOperator, {})
2296 DEF_TRAVERSE_STMT(CompoundAssignOperator, {})
2297 DEF_TRAVERSE_STMT(CXXNoexceptExpr, {})
2298 DEF_TRAVERSE_STMT(PackExpansionExpr, {})
2299 DEF_TRAVERSE_STMT(SizeOfPackExpr, {})
2300 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {})
2301 DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {})
2302 DEF_TRAVERSE_STMT(FunctionParmPackExpr, {})
2303 DEF_TRAVERSE_STMT(MaterializeTemporaryExpr, {})
2304 DEF_TRAVERSE_STMT(CXXFoldExpr, {})
2305 DEF_TRAVERSE_STMT(AtomicExpr, {})
2306 
2307 // These literals (all of them) do not need any action.
2308 DEF_TRAVERSE_STMT(IntegerLiteral, {})
2309 DEF_TRAVERSE_STMT(CharacterLiteral, {})
2310 DEF_TRAVERSE_STMT(FloatingLiteral, {})
2311 DEF_TRAVERSE_STMT(ImaginaryLiteral, {})
2312 DEF_TRAVERSE_STMT(StringLiteral, {})
2313 DEF_TRAVERSE_STMT(ObjCStringLiteral, {})
2314 DEF_TRAVERSE_STMT(ObjCBoxedExpr, {})
2315 DEF_TRAVERSE_STMT(ObjCArrayLiteral, {})
2316 DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, {})
2317 
2318 // Traverse OpenCL: AsType, Convert.
2319 DEF_TRAVERSE_STMT(AsTypeExpr, {})
2320 
2321 // OpenMP directives.
2322 template <typename Derived>
2323 bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
2324  OMPExecutableDirective *S) {
2325  for (auto *C : S->clauses()) {
2326  TRY_TO(TraverseOMPClause(C));
2327  }
2328  return true;
2329 }
2330 
2331 template <typename Derived>
2332 bool
2333 RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) {
2334  return TraverseOMPExecutableDirective(S);
2335 }
2336 
2337 DEF_TRAVERSE_STMT(OMPParallelDirective,
2338  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2339 
2340 DEF_TRAVERSE_STMT(OMPSimdDirective,
2341  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2342 
2343 DEF_TRAVERSE_STMT(OMPForDirective,
2344  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2345 
2346 DEF_TRAVERSE_STMT(OMPForSimdDirective,
2347  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2348 
2349 DEF_TRAVERSE_STMT(OMPSectionsDirective,
2350  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2351 
2352 DEF_TRAVERSE_STMT(OMPSectionDirective,
2353  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2354 
2355 DEF_TRAVERSE_STMT(OMPSingleDirective,
2356  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2357 
2358 DEF_TRAVERSE_STMT(OMPMasterDirective,
2359  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2360 
2361 DEF_TRAVERSE_STMT(OMPCriticalDirective, {
2362  TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName()));
2363  TRY_TO(TraverseOMPExecutableDirective(S));
2364 })
2365 
2366 DEF_TRAVERSE_STMT(OMPParallelForDirective,
2367  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2368 
2369 DEF_TRAVERSE_STMT(OMPParallelForSimdDirective,
2370  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2371 
2372 DEF_TRAVERSE_STMT(OMPParallelSectionsDirective,
2373  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2374 
2375 DEF_TRAVERSE_STMT(OMPTaskDirective,
2376  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2377 
2378 DEF_TRAVERSE_STMT(OMPTaskyieldDirective,
2379  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2380 
2381 DEF_TRAVERSE_STMT(OMPBarrierDirective,
2382  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2383 
2384 DEF_TRAVERSE_STMT(OMPTaskwaitDirective,
2385  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2386 
2387 DEF_TRAVERSE_STMT(OMPTaskgroupDirective,
2388  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2389 
2390 DEF_TRAVERSE_STMT(OMPCancellationPointDirective,
2391  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2392 
2393 DEF_TRAVERSE_STMT(OMPCancelDirective,
2394  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2395 
2396 DEF_TRAVERSE_STMT(OMPFlushDirective,
2397  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2398 
2399 DEF_TRAVERSE_STMT(OMPOrderedDirective,
2400  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2401 
2402 DEF_TRAVERSE_STMT(OMPAtomicDirective,
2403  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2404 
2405 DEF_TRAVERSE_STMT(OMPTargetDirective,
2406  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2407 
2408 DEF_TRAVERSE_STMT(OMPTeamsDirective,
2409  { TRY_TO(TraverseOMPExecutableDirective(S)); })
2410 
2411 // OpenMP clauses.
2412 template <typename Derived>
2413 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
2414  if (!C)
2415  return true;
2416  switch (C->getClauseKind()) {
2417 #define OPENMP_CLAUSE(Name, Class) \
2418  case OMPC_##Name: \
2419  TRY_TO(Visit##Class(static_cast<Class *>(C))); \
2420  break;
2421 #include "clang/Basic/OpenMPKinds.def"
2422  case OMPC_threadprivate:
2423  case OMPC_unknown:
2424  break;
2425  }
2426  return true;
2427 }
2428 
2429 template <typename Derived>
2430 bool RecursiveASTVisitor<Derived>::VisitOMPIfClause(OMPIfClause *C) {
2431  TRY_TO(TraverseStmt(C->getCondition()));
2432  return true;
2433 }
2434 
2435 template <typename Derived>
2436 bool RecursiveASTVisitor<Derived>::VisitOMPFinalClause(OMPFinalClause *C) {
2437  TRY_TO(TraverseStmt(C->getCondition()));
2438  return true;
2439 }
2440 
2441 template <typename Derived>
2442 bool
2443 RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
2444  TRY_TO(TraverseStmt(C->getNumThreads()));
2445  return true;
2446 }
2447 
2448 template <typename Derived>
2449 bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) {
2450  TRY_TO(TraverseStmt(C->getSafelen()));
2451  return true;
2452 }
2453 
2454 template <typename Derived>
2455 bool
2456 RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) {
2457  TRY_TO(TraverseStmt(C->getNumForLoops()));
2458  return true;
2459 }
2460 
2461 template <typename Derived>
2462 bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) {
2463  return true;
2464 }
2465 
2466 template <typename Derived>
2467 bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) {
2468  return true;
2469 }
2470 
2471 template <typename Derived>
2472 bool
2473 RecursiveASTVisitor<Derived>::VisitOMPScheduleClause(OMPScheduleClause *C) {
2474  TRY_TO(TraverseStmt(C->getChunkSize()));
2475  TRY_TO(TraverseStmt(C->getHelperChunkSize()));
2476  return true;
2477 }
2478 
2479 template <typename Derived>
2480 bool RecursiveASTVisitor<Derived>::VisitOMPOrderedClause(OMPOrderedClause *) {
2481  return true;
2482 }
2483 
2484 template <typename Derived>
2485 bool RecursiveASTVisitor<Derived>::VisitOMPNowaitClause(OMPNowaitClause *) {
2486  return true;
2487 }
2488 
2489 template <typename Derived>
2490 bool RecursiveASTVisitor<Derived>::VisitOMPUntiedClause(OMPUntiedClause *) {
2491  return true;
2492 }
2493 
2494 template <typename Derived>
2495 bool
2496 RecursiveASTVisitor<Derived>::VisitOMPMergeableClause(OMPMergeableClause *) {
2497  return true;
2498 }
2499 
2500 template <typename Derived>
2501 bool RecursiveASTVisitor<Derived>::VisitOMPReadClause(OMPReadClause *) {
2502  return true;
2503 }
2504 
2505 template <typename Derived>
2506 bool RecursiveASTVisitor<Derived>::VisitOMPWriteClause(OMPWriteClause *) {
2507  return true;
2508 }
2509 
2510 template <typename Derived>
2511 bool RecursiveASTVisitor<Derived>::VisitOMPUpdateClause(OMPUpdateClause *) {
2512  return true;
2513 }
2514 
2515 template <typename Derived>
2516 bool RecursiveASTVisitor<Derived>::VisitOMPCaptureClause(OMPCaptureClause *) {
2517  return true;
2518 }
2519 
2520 template <typename Derived>
2521 bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) {
2522  return true;
2523 }
2524 
2525 template <typename Derived>
2526 template <typename T>
2527 bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
2528  for (auto *E : Node->varlists()) {
2529  TRY_TO(TraverseStmt(E));
2530  }
2531  return true;
2532 }
2533 
2534 template <typename Derived>
2535 bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
2536  TRY_TO(VisitOMPClauseList(C));
2537  for (auto *E : C->private_copies()) {
2538  TRY_TO(TraverseStmt(E));
2539  }
2540  return true;
2541 }
2542 
2543 template <typename Derived>
2544 bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
2545  OMPFirstprivateClause *C) {
2546  TRY_TO(VisitOMPClauseList(C));
2547  for (auto *E : C->private_copies()) {
2548  TRY_TO(TraverseStmt(E));
2549  }
2550  for (auto *E : C->inits()) {
2551  TRY_TO(TraverseStmt(E));
2552  }
2553  return true;
2554 }
2555 
2556 template <typename Derived>
2557 bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause(
2558  OMPLastprivateClause *C) {
2559  TRY_TO(VisitOMPClauseList(C));
2560  for (auto *E : C->private_copies()) {
2561  TRY_TO(TraverseStmt(E));
2562  }
2563  for (auto *E : C->source_exprs()) {
2564  TRY_TO(TraverseStmt(E));
2565  }
2566  for (auto *E : C->destination_exprs()) {
2567  TRY_TO(TraverseStmt(E));
2568  }
2569  for (auto *E : C->assignment_ops()) {
2570  TRY_TO(TraverseStmt(E));
2571  }
2572  return true;
2573 }
2574 
2575 template <typename Derived>
2576 bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
2577  TRY_TO(VisitOMPClauseList(C));
2578  return true;
2579 }
2580 
2581 template <typename Derived>
2582 bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(OMPLinearClause *C) {
2583  TRY_TO(TraverseStmt(C->getStep()));
2584  TRY_TO(TraverseStmt(C->getCalcStep()));
2585  TRY_TO(VisitOMPClauseList(C));
2586  for (auto *E : C->inits()) {
2587  TRY_TO(TraverseStmt(E));
2588  }
2589  for (auto *E : C->updates()) {
2590  TRY_TO(TraverseStmt(E));
2591  }
2592  for (auto *E : C->finals()) {
2593  TRY_TO(TraverseStmt(E));
2594  }
2595  return true;
2596 }
2597 
2598 template <typename Derived>
2599 bool RecursiveASTVisitor<Derived>::VisitOMPAlignedClause(OMPAlignedClause *C) {
2600  TRY_TO(TraverseStmt(C->getAlignment()));
2601  TRY_TO(VisitOMPClauseList(C));
2602  return true;
2603 }
2604 
2605 template <typename Derived>
2606 bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(OMPCopyinClause *C) {
2607  TRY_TO(VisitOMPClauseList(C));
2608  for (auto *E : C->source_exprs()) {
2609  TRY_TO(TraverseStmt(E));
2610  }
2611  for (auto *E : C->destination_exprs()) {
2612  TRY_TO(TraverseStmt(E));
2613  }
2614  for (auto *E : C->assignment_ops()) {
2615  TRY_TO(TraverseStmt(E));
2616  }
2617  return true;
2618 }
2619 
2620 template <typename Derived>
2621 bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause(
2622  OMPCopyprivateClause *C) {
2623  TRY_TO(VisitOMPClauseList(C));
2624  for (auto *E : C->source_exprs()) {
2625  TRY_TO(TraverseStmt(E));
2626  }
2627  for (auto *E : C->destination_exprs()) {
2628  TRY_TO(TraverseStmt(E));
2629  }
2630  for (auto *E : C->assignment_ops()) {
2631  TRY_TO(TraverseStmt(E));
2632  }
2633  return true;
2634 }
2635 
2636 template <typename Derived>
2637 bool
2638 RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) {
2639  TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc()));
2640  TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo()));
2641  TRY_TO(VisitOMPClauseList(C));
2642  for (auto *E : C->lhs_exprs()) {
2643  TRY_TO(TraverseStmt(E));
2644  }
2645  for (auto *E : C->rhs_exprs()) {
2646  TRY_TO(TraverseStmt(E));
2647  }
2648  for (auto *E : C->reduction_ops()) {
2649  TRY_TO(TraverseStmt(E));
2650  }
2651  return true;
2652 }
2653 
2654 template <typename Derived>
2655 bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) {
2656  TRY_TO(VisitOMPClauseList(C));
2657  return true;
2658 }
2659 
2660 template <typename Derived>
2661 bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) {
2662  TRY_TO(VisitOMPClauseList(C));
2663  return true;
2664 }
2665 
2666 // FIXME: look at the following tricky-seeming exprs to see if we
2667 // need to recurse on anything. These are ones that have methods
2668 // returning decls or qualtypes or nestednamespecifier -- though I'm
2669 // not sure if they own them -- or just seemed very complicated, or
2670 // had lots of sub-types to explore.
2671 //
2672 // VisitOverloadExpr and its children: recurse on template args? etc?
2673 
2674 // FIXME: go through all the stmts and exprs again, and see which of them
2675 // create new types, and recurse on the types (TypeLocs?) of those.
2676 // Candidates:
2677 //
2678 // http://clang.llvm.org/doxygen/classclang_1_1CXXTypeidExpr.html
2679 // http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html
2680 // http://clang.llvm.org/doxygen/classclang_1_1TypesCompatibleExpr.html
2681 // Every class that has getQualifier.
2682 
2683 #undef DEF_TRAVERSE_STMT
2684 
2685 #undef TRY_TO
2686 
2687 #undef RecursiveASTVisitor
2688 
2689 } // end namespace clang
2690 
2691 #endif // LLVM_CLANG_LIBCLANG_RECURSIVEASTVISITOR_H
Expr * getSourceExpression() const
Definition: TemplateBase.h:479
This represents clause 'copyin' in the '#pragma omp ...' directives.
helper_expr_const_range source_exprs() const
bool TraverseLambdaBody(LambdaExpr *LE)
Recursively visit the body of a lambda expression.
Expr *const * semantics_iterator
Definition: Expr.h:4778
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
NestedNameSpecifierLoc getPrefix() const
Return the prefix of this nested-name-specifier.
Defines the C++ template declaration subclasses.
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:317
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
A container of type source information.
Definition: Decl.h:60
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:307
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
Expr * getAlignment()
Returns alignment.
An identifier, stored as an IdentifierInfo*.
TRY_TO(TraverseType(T->getPointeeType()))
Expr * getInit() const
Get the initializer.
Definition: DeclCXX.h:2134
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Definition: TypeLoc.h:239
Derived & getDerived()
Return a reference to the derived class.
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:45
A namespace, stored as a NamespaceDecl*.
This represents implicit clause 'flush' for the '#pragma omp flush' directive. This clause does not e...
Defines the Objective-C statement AST node classes.
Defines the clang::Expr interface and subclasses for C++ expressions.
bool TraverseDecl(Decl *D)
Recursively visit a declaration, by dispatching to Traverse*Decl() based on the argument's dynamic ty...
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
DeclarationName getName() const
getName - Returns the embedded declaration name.
bool isNull() const
Definition: TypeLoc.h:95
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:440
bool shouldVisitTemplateInstantiations() const
Return whether this visitor should recurse into template instantiations.
bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C)
Recursively visit a lambda capture.
#define STMT(CLASS, PARENT)
Wrapper of type source information for a type with no direct qualifiers.
Definition: TypeLoc.h:214
TypeSourceInfo * getTypeSourceInfo() const
Definition: TemplateBase.h:474
TypeSourceInfo * getNamedTypeInfo() const
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
#define RecursiveASTVisitor
bool isImplicit() const
Definition: DeclBase.h:503
NamedDecl ** iterator
Iterates through the template parameters in this list.
Definition: DeclTemplate.h:75
bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo)
Recursively visit a name with its location information.
NestedNameSpecifierLoc getTemplateQualifierLoc() const
Definition: TemplateBase.h:499
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2918
TypeClass getTypeClass() const
Definition: Type.h:1486
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
Definition: LambdaCapture.h:93
CompoundStmt * getBody() const
Retrieve the body of the lambda.
Definition: ExprCXX.cpp:1101
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
A class that does preorder depth-first traversal on the entire Clang AST and visits each node...
bool isWritten() const
Determine whether this initializer is explicitly written in the source code.
Definition: DeclCXX.h:2078
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
Definition: TemplateName.h:284
TypeLoc getTypeLoc() const
For a nested-name-specifier that refers to a type, retrieve the type with source-location information...
This represents clause 'aligned' in the '#pragma omp ...' directives.
DEF_TRAVERSE_TYPE(ComplexType,{TRY_TO(TraverseType(T->getElementType()));}) DEF_TRAVERSE_TYPE(PointerType
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
bool TraverseConstructorInitializer(CXXCtorInitializer *Init)
Recursively visit a constructor initializer. This automatically dispatches to another visitor for the...
helper_expr_const_range assignment_ops() const
bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL)
Kind getKind() const
Definition: DeclBase.h:375
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:218
#define bool
Definition: stdbool.h:31
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:350
bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL)
Represents a C++ template name within the type system.
Definition: TemplateName.h:175
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, unsigned NumVars)
Build 'linear' clause with given number of variables NumVars.
Definition: OpenMPClause.h:276
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:271
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
DEF_TRAVERSE_TYPELOC(ComplexType,{TRY_TO(TraverseType(TL.getTypePtr() ->getElementType()));}) DEF_TRAVERSE_TYPELOC(PointerType
return TraverseArrayTypeLocHelper(TL)
#define TYPE(CLASS, BASE)
helper_expr_const_range destination_exprs() const
#define BINOP_LIST()
bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL)
#define DEF_TRAVERSE_DECL(DECL, CODE)
bool TraverseTypeLoc(TypeLoc TL)
Recursively visit a type with location, by dispatching to Traverse*TypeLoc() based on the argument ty...
attr_range attrs() const
Definition: DeclBase.h:447
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Recursively visit a C++ nested-name-specifier with location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This file defines OpenMP nodes for declarative directives.
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
Definition: ExprCXX.cpp:1030
TypeLocClass getTypeLocClass() const
Definition: TypeLoc.h:90
bool TraverseType(QualType T)
Recursively visit a type, by dispatching to Traverse*Type() based on the argument's getTypeClass() pr...
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
Definition: TemplateName.h:278
#define DEF_TRAVERSE_STMT(STMT, CODE)
ast_type_traits::DynTypedNode Node
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
Represents a template argument.
Definition: TemplateBase.h:39
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:240
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:383
TypeSourceInfo * getTypeSourceInfo() const
Returns the declarator information for a base class or delegating initializer.
Definition: DeclCXX.h:2041
return(x >> y)|(x<< (32-y))
const internal::VariadicDynCastAllOfMatcher< Stmt, CUDAKernelCallExpr > CUDAKernelCallExpr
Matches CUDA kernel call expression.
Definition: ASTMatchers.h:4113
for(auto typeArg:T->getTypeArgsAsWritten())
A type that was preceded by the 'template' keyword, stored as a Type*.
This file defines OpenMP AST classes for executable directives and clauses.
bool TraverseTemplateArgument(const TemplateArgument &Arg)
Recursively visit a template argument and dispatch to the appropriate method for the argument type...
Represents a C++ base or member initializer.
Definition: DeclCXX.h:1901
UnqualTypeLoc getUnqualifiedLoc() const
Definition: TypeLoc.h:245
The template argument is a type.
Definition: TemplateBase.h:47
bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS)
Recursively visit a C++ nested-name-specifier.
helper_expr_const_range destination_exprs() const
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:337
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
const Capture * capture_iterator
An iterator that walks over the captures of the lambda, both implicit and explicit.
Definition: ExprCXX.h:1460
bool TraverseTemplateArguments(const TemplateArgument *Args, unsigned NumArgs)
Recursively visit a set of template arguments. This can be overridden by a subclass, but it's not expected that will be needed – this visitor always dispatches to another.
#define UNARYOP_LIST()
bool TraverseAttr(Attr *At)
Recursively visit an attribute, by dispatching to Traverse*Attr() based on the argument's dynamic typ...
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:289
bool VisitUnqualTypeLoc(UnqualTypeLoc TL)
bool isNull() const
isNull - Return true if this QualType doesn't point to a type yet.
Definition: Type.h:633
The global specifier '::'. There is no stored value.
bool shouldWalkTypesOfTypeLocs() const
Return whether this visitor should recurse into the types of TypeLocs.
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:466
bool TraverseStmt(Stmt *S)
Recursively visit a statement or expression, by dispatching to Traverse*() based on the argument's dy...
bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc)
Recursively visit a template argument location and dispatch to the appropriate method for the argumen...
Attr - This represents one attribute.
Definition: Attr.h:44
#define CAO_LIST()
helper_expr_const_range assignment_ops() const
helper_expr_const_range source_exprs() const