1//===--- RecursiveASTVisitor.h - 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 RecursiveASTVisitor interface, which recursively 11// traverses the entire AST. 12// 13//===----------------------------------------------------------------------===// 14#ifndef LLVM_CLANG_AST_RECURSIVEASTVISITOR_H 15#define LLVM_CLANG_AST_RECURSIVEASTVISITOR_H 16 17#include "clang/AST/Attr.h" 18#include "clang/AST/Decl.h" 19#include "clang/AST/DeclarationName.h" 20#include "clang/AST/DeclBase.h" 21#include "clang/AST/DeclCXX.h" 22#include "clang/AST/DeclFriend.h" 23#include "clang/AST/DeclObjC.h" 24#include "clang/AST/DeclOpenMP.h" 25#include "clang/AST/DeclTemplate.h" 26#include "clang/AST/Expr.h" 27#include "clang/AST/ExprCXX.h" 28#include "clang/AST/ExprObjC.h" 29#include "clang/AST/ExprOpenMP.h" 30#include "clang/AST/LambdaCapture.h" 31#include "clang/AST/NestedNameSpecifier.h" 32#include "clang/AST/OpenMPClause.h" 33#include "clang/AST/Stmt.h" 34#include "clang/AST/StmtCXX.h" 35#include "clang/AST/StmtObjC.h" 36#include "clang/AST/StmtOpenMP.h" 37#include "clang/AST/TemplateBase.h" 38#include "clang/AST/TemplateName.h" 39#include "clang/AST/Type.h" 40#include "clang/AST/TypeLoc.h" 41#include "clang/Basic/LLVM.h" 42#include "clang/Basic/OpenMPKinds.h" 43#include "clang/Basic/Specifiers.h" 44#include "llvm/ADT/PointerIntPair.h" 45#include "llvm/ADT/SmallVector.h" 46#include "llvm/Support/Casting.h" 47#include <algorithm> 48#include <cstddef> 49#include <type_traits> 50 51// The following three macros are used for meta programming. The code 52// using them is responsible for defining macro OPERATOR(). 53 54// All unary operators. 55#define UNARYOP_LIST() \ 56 OPERATOR(PostInc) OPERATOR(PostDec) OPERATOR(PreInc) OPERATOR(PreDec) \ 57 OPERATOR(AddrOf) OPERATOR(Deref) OPERATOR(Plus) OPERATOR(Minus) \ 58 OPERATOR(Not) OPERATOR(LNot) OPERATOR(Real) OPERATOR(Imag) \ 59 OPERATOR(Extension) OPERATOR(Coawait) 60 61// All binary operators (excluding compound assign operators). 62#define BINOP_LIST() \ 63 OPERATOR(PtrMemD) OPERATOR(PtrMemI) OPERATOR(Mul) OPERATOR(Div) \ 64 OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) OPERATOR(Shl) OPERATOR(Shr) \ 65 OPERATOR(LT) OPERATOR(GT) OPERATOR(LE) OPERATOR(GE) OPERATOR(EQ) \ 66 OPERATOR(NE) OPERATOR(And) OPERATOR(Xor) OPERATOR(Or) OPERATOR(LAnd) \ 67 OPERATOR(LOr) OPERATOR(Assign) OPERATOR(Comma) 68 69// All compound assign operators. 70#define CAO_LIST() \ 71 OPERATOR(Mul) OPERATOR(Div) OPERATOR(Rem) OPERATOR(Add) OPERATOR(Sub) \ 72 OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor) 73 74namespace clang { 75 76// A helper macro to implement short-circuiting when recursing. It 77// invokes CALL_EXPR, which must be a method call, on the derived 78// object (s.t. a user of RecursiveASTVisitor can override the method 79// in CALL_EXPR). 80#define TRY_TO(CALL_EXPR) \ 81 do { \ 82 if (!getDerived().CALL_EXPR) \ 83 return false; \ 84 } while (false) 85 86/// \brief A class that does preorder or postorder 87/// depth-first traversal on the entire Clang AST and visits each node. 88/// 89/// This class performs three distinct tasks: 90/// 1. traverse the AST (i.e. go to each node); 91/// 2. at a given node, walk up the class hierarchy, starting from 92/// the node's dynamic type, until the top-most class (e.g. Stmt, 93/// Decl, or Type) is reached. 94/// 3. given a (node, class) combination, where 'class' is some base 95/// class of the dynamic type of 'node', call a user-overridable 96/// function to actually visit the node. 97/// 98/// These tasks are done by three groups of methods, respectively: 99/// 1. TraverseDecl(Decl *x) does task #1. It is the entry point 100/// for traversing an AST rooted at x. This method simply 101/// dispatches (i.e. forwards) to TraverseFoo(Foo *x) where Foo 102/// is the dynamic type of *x, which calls WalkUpFromFoo(x) and 103/// then recursively visits the child nodes of x. 104/// TraverseStmt(Stmt *x) and TraverseType(QualType x) work 105/// similarly. 106/// 2. WalkUpFromFoo(Foo *x) does task #2. It does not try to visit 107/// any child node of x. Instead, it first calls WalkUpFromBar(x) 108/// where Bar is the direct parent class of Foo (unless Foo has 109/// no parent), and then calls VisitFoo(x) (see the next list item). 110/// 3. VisitFoo(Foo *x) does task #3. 111/// 112/// These three method groups are tiered (Traverse* > WalkUpFrom* > 113/// Visit*). A method (e.g. Traverse*) may call methods from the same 114/// tier (e.g. other Traverse*) or one tier lower (e.g. WalkUpFrom*). 115/// It may not call methods from a higher tier. 116/// 117/// Note that since WalkUpFromFoo() calls WalkUpFromBar() (where Bar 118/// is Foo's super class) before calling VisitFoo(), the result is 119/// that the Visit*() methods for a given node are called in the 120/// top-down order (e.g. for a node of type NamespaceDecl, the order will 121/// be VisitDecl(), VisitNamedDecl(), and then VisitNamespaceDecl()). 122/// 123/// This scheme guarantees that all Visit*() calls for the same AST 124/// node are grouped together. In other words, Visit*() methods for 125/// different nodes are never interleaved. 126/// 127/// Clients of this visitor should subclass the visitor (providing 128/// themselves as the template argument, using the curiously recurring 129/// template pattern) and override any of the Traverse*, WalkUpFrom*, 130/// and Visit* methods for declarations, types, statements, 131/// expressions, or other AST nodes where the visitor should customize 132/// behavior. Most users only need to override Visit*. Advanced 133/// users may override Traverse* and WalkUpFrom* to implement custom 134/// traversal strategies. Returning false from one of these overridden 135/// functions will abort the entire traversal. 136/// 137/// By default, this visitor tries to visit every part of the explicit 138/// source code exactly once. The default policy towards templates 139/// is to descend into the 'pattern' class or function body, not any 140/// explicit or implicit instantiations. Explicit specializations 141/// are still visited, and the patterns of partial specializations 142/// are visited separately. This behavior can be changed by 143/// overriding shouldVisitTemplateInstantiations() in the derived class 144/// to return true, in which case all known implicit and explicit 145/// instantiations will be visited at the same time as the pattern 146/// from which they were produced. 147/// 148/// By default, this visitor preorder traverses the AST. If postorder traversal 149/// is needed, the \c shouldTraversePostOrder method needs to be overriden 150/// to return \c true. 151template <typename Derived> class RecursiveASTVisitor { 152public: 153 /// A queue used for performing data recursion over statements. 154 /// Parameters involving this type are used to implement data 155 /// recursion over Stmts and Exprs within this class, and should 156 /// typically not be explicitly specified by derived classes. 157 /// The bool bit indicates whether the statement has been traversed or not. 158 typedef SmallVectorImpl<llvm::PointerIntPair<Stmt *, 1, bool>> 159 DataRecursionQueue; 160 161 /// \brief Return a reference to the derived class. 162 Derived &getDerived() { return *static_cast<Derived *>(this); } 163 164 /// \brief Return whether this visitor should recurse into 165 /// template instantiations. 166 bool shouldVisitTemplateInstantiations() const { return false; } 167 168 /// \brief Return whether this visitor should recurse into the types of 169 /// TypeLocs. 170 bool shouldWalkTypesOfTypeLocs() const { return true; } 171 172 /// \brief Return whether this visitor should recurse into implicit 173 /// code, e.g., implicit constructors and destructors. 174 bool shouldVisitImplicitCode() const { return false; } 175 176 /// \brief Return whether this visitor should traverse post-order. 177 bool shouldTraversePostOrder() const { return false; } 178 179 /// \brief Recursively visit a statement or expression, by 180 /// dispatching to Traverse*() based on the argument's dynamic type. 181 /// 182 /// \returns false if the visitation was terminated early, true 183 /// otherwise (including when the argument is nullptr). 184 bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = nullptr); 185 186 /// Invoked before visiting a statement or expression via data recursion. 187 /// 188 /// \returns false to skip visiting the node, true otherwise. 189 bool dataTraverseStmtPre(Stmt *S) { return true; } 190 191 /// Invoked after visiting a statement or expression via data recursion. 192 /// This is not invoked if the previously invoked \c dataTraverseStmtPre 193 /// returned false. 194 /// 195 /// \returns false if the visitation was terminated early, true otherwise. 196 bool dataTraverseStmtPost(Stmt *S) { return true; } 197 198 /// \brief Recursively visit a type, by dispatching to 199 /// Traverse*Type() based on the argument's getTypeClass() property. 200 /// 201 /// \returns false if the visitation was terminated early, true 202 /// otherwise (including when the argument is a Null type). 203 bool TraverseType(QualType T); 204 205 /// \brief Recursively visit a type with location, by dispatching to 206 /// Traverse*TypeLoc() based on the argument type's getTypeClass() property. 207 /// 208 /// \returns false if the visitation was terminated early, true 209 /// otherwise (including when the argument is a Null type location). 210 bool TraverseTypeLoc(TypeLoc TL); 211 212 /// \brief Recursively visit an attribute, by dispatching to 213 /// Traverse*Attr() based on the argument's dynamic type. 214 /// 215 /// \returns false if the visitation was terminated early, true 216 /// otherwise (including when the argument is a Null type location). 217 bool TraverseAttr(Attr *At); 218 219 /// \brief Recursively visit a declaration, by dispatching to 220 /// Traverse*Decl() based on the argument's dynamic type. 221 /// 222 /// \returns false if the visitation was terminated early, true 223 /// otherwise (including when the argument is NULL). 224 bool TraverseDecl(Decl *D); 225 226 /// \brief Recursively visit a C++ nested-name-specifier. 227 /// 228 /// \returns false if the visitation was terminated early, true otherwise. 229 bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS); 230 231 /// \brief Recursively visit a C++ nested-name-specifier with location 232 /// information. 233 /// 234 /// \returns false if the visitation was terminated early, true otherwise. 235 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS); 236 237 /// \brief Recursively visit a name with its location information. 238 /// 239 /// \returns false if the visitation was terminated early, true otherwise. 240 bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo); 241 242 /// \brief Recursively visit a template name and dispatch to the 243 /// appropriate method. 244 /// 245 /// \returns false if the visitation was terminated early, true otherwise. 246 bool TraverseTemplateName(TemplateName Template); 247 248 /// \brief Recursively visit a template argument and dispatch to the 249 /// appropriate method for the argument type. 250 /// 251 /// \returns false if the visitation was terminated early, true otherwise. 252 // FIXME: migrate callers to TemplateArgumentLoc instead. 253 bool TraverseTemplateArgument(const TemplateArgument &Arg); 254 255 /// \brief Recursively visit a template argument location and dispatch to the 256 /// appropriate method for the argument type. 257 /// 258 /// \returns false if the visitation was terminated early, true otherwise. 259 bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc); 260 261 /// \brief Recursively visit a set of template arguments. 262 /// This can be overridden by a subclass, but it's not expected that 263 /// will be needed -- this visitor always dispatches to another. 264 /// 265 /// \returns false if the visitation was terminated early, true otherwise. 266 // FIXME: take a TemplateArgumentLoc* (or TemplateArgumentListInfo) instead. 267 bool TraverseTemplateArguments(const TemplateArgument *Args, 268 unsigned NumArgs); 269 270 /// \brief Recursively visit a base specifier. This can be overridden by a 271 /// subclass. 272 /// 273 /// \returns false if the visitation was terminated early, true otherwise. 274 bool TraverseCXXBaseSpecifier(const CXXBaseSpecifier &Base); 275 276 /// \brief Recursively visit a constructor initializer. This 277 /// automatically dispatches to another visitor for the initializer 278 /// expression, but not for the name of the initializer, so may 279 /// be overridden for clients that need access to the name. 280 /// 281 /// \returns false if the visitation was terminated early, true otherwise. 282 bool TraverseConstructorInitializer(CXXCtorInitializer *Init); 283 284 /// \brief Recursively visit a lambda capture. \c Init is the expression that 285 /// will be used to initialize the capture. 286 /// 287 /// \returns false if the visitation was terminated early, true otherwise. 288 bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, 289 Expr *Init); 290 291 /// \brief Recursively visit the body of a lambda expression. 292 /// 293 /// This provides a hook for visitors that need more context when visiting 294 /// \c LE->getBody(). 295 /// 296 /// \returns false if the visitation was terminated early, true otherwise. 297 bool TraverseLambdaBody(LambdaExpr *LE, DataRecursionQueue *Queue = nullptr); 298 299 /// \brief Recursively visit the syntactic or semantic form of an 300 /// initialization list. 301 /// 302 /// \returns false if the visitation was terminated early, true otherwise. 303 bool TraverseSynOrSemInitListExpr(InitListExpr *S, 304 DataRecursionQueue *Queue = nullptr); 305 306 // ---- Methods on Attrs ---- 307 308 // \brief Visit an attribute. 309 bool VisitAttr(Attr *A) { return true; } 310 311// Declare Traverse* and empty Visit* for all Attr classes. 312#define ATTR_VISITOR_DECLS_ONLY 313#include "clang/AST/AttrVisitor.inc" 314#undef ATTR_VISITOR_DECLS_ONLY 315 316// ---- Methods on Stmts ---- 317 318 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); } 319 320private: 321 template<typename T, typename U> 322 struct has_same_member_pointer_type : std::false_type {}; 323 template<typename T, typename U, typename R, typename... P> 324 struct has_same_member_pointer_type<R (T::*)(P...), R (U::*)(P...)> 325 : std::true_type {}; 326 327 // Traverse the given statement. If the most-derived traverse function takes a 328 // data recursion queue, pass it on; otherwise, discard it. Note that the 329 // first branch of this conditional must compile whether or not the derived 330 // class can take a queue, so if we're taking the second arm, make the first 331 // arm call our function rather than the derived class version. 332#define TRAVERSE_STMT_BASE(NAME, CLASS, VAR, QUEUE) \ 333 (has_same_member_pointer_type<decltype( \ 334 &RecursiveASTVisitor::Traverse##NAME), \ 335 decltype(&Derived::Traverse##NAME)>::value \ 336 ? static_cast<typename std::conditional< \ 337 has_same_member_pointer_type< \ 338 decltype(&RecursiveASTVisitor::Traverse##NAME), \ 339 decltype(&Derived::Traverse##NAME)>::value, \ 340 Derived &, RecursiveASTVisitor &>::type>(*this) \ 341 .Traverse##NAME(static_cast<CLASS *>(VAR), QUEUE) \ 342 : getDerived().Traverse##NAME(static_cast<CLASS *>(VAR))) 343 344// Try to traverse the given statement, or enqueue it if we're performing data 345// recursion in the middle of traversing another statement. Can only be called 346// from within a DEF_TRAVERSE_STMT body or similar context. 347#define TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S) \ 348 do { \ 349 if (!TRAVERSE_STMT_BASE(Stmt, Stmt, S, Queue)) \ 350 return false; \ 351 } while (false) 352 353public: 354// Declare Traverse*() for all concrete Stmt classes. 355#define ABSTRACT_STMT(STMT) 356#define STMT(CLASS, PARENT) \ 357 bool Traverse##CLASS(CLASS *S, DataRecursionQueue *Queue = nullptr); 358#include "clang/AST/StmtNodes.inc" 359 // The above header #undefs ABSTRACT_STMT and STMT upon exit. 360 361 // Define WalkUpFrom*() and empty Visit*() for all Stmt classes. 362 bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); } 363 bool VisitStmt(Stmt *S) { return true; } 364#define STMT(CLASS, PARENT) \ 365 bool WalkUpFrom##CLASS(CLASS *S) { \ 366 TRY_TO(WalkUpFrom##PARENT(S)); \ 367 TRY_TO(Visit##CLASS(S)); \ 368 return true; \ 369 } \ 370 bool Visit##CLASS(CLASS *S) { return true; } 371#include "clang/AST/StmtNodes.inc" 372 373// Define Traverse*(), WalkUpFrom*(), and Visit*() for unary 374// operator methods. Unary operators are not classes in themselves 375// (they're all opcodes in UnaryOperator) but do have visitors. 376#define OPERATOR(NAME) \ 377 bool TraverseUnary##NAME(UnaryOperator *S, \ 378 DataRecursionQueue *Queue = nullptr) { \ 379 if (!getDerived().shouldTraversePostOrder()) \ 380 TRY_TO(WalkUpFromUnary##NAME(S)); \ 381 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSubExpr()); \ 382 return true; \ 383 } \ 384 bool WalkUpFromUnary##NAME(UnaryOperator *S) { \ 385 TRY_TO(WalkUpFromUnaryOperator(S)); \ 386 TRY_TO(VisitUnary##NAME(S)); \ 387 return true; \ 388 } \ 389 bool VisitUnary##NAME(UnaryOperator *S) { return true; } 390 391 UNARYOP_LIST() 392#undef OPERATOR 393 394// Define Traverse*(), WalkUpFrom*(), and Visit*() for binary 395// operator methods. Binary operators are not classes in themselves 396// (they're all opcodes in BinaryOperator) but do have visitors. 397#define GENERAL_BINOP_FALLBACK(NAME, BINOP_TYPE) \ 398 bool TraverseBin##NAME(BINOP_TYPE *S, DataRecursionQueue *Queue = nullptr) { \ 399 if (!getDerived().shouldTraversePostOrder()) \ 400 TRY_TO(WalkUpFromBin##NAME(S)); \ 401 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getLHS()); \ 402 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getRHS()); \ 403 return true; \ 404 } \ 405 bool WalkUpFromBin##NAME(BINOP_TYPE *S) { \ 406 TRY_TO(WalkUpFrom##BINOP_TYPE(S)); \ 407 TRY_TO(VisitBin##NAME(S)); \ 408 return true; \ 409 } \ 410 bool VisitBin##NAME(BINOP_TYPE *S) { return true; } 411 412#define OPERATOR(NAME) GENERAL_BINOP_FALLBACK(NAME, BinaryOperator) 413 BINOP_LIST() 414#undef OPERATOR 415 416// Define Traverse*(), WalkUpFrom*(), and Visit*() for compound 417// assignment methods. Compound assignment operators are not 418// classes in themselves (they're all opcodes in 419// CompoundAssignOperator) but do have visitors. 420#define OPERATOR(NAME) \ 421 GENERAL_BINOP_FALLBACK(NAME##Assign, CompoundAssignOperator) 422 423 CAO_LIST() 424#undef OPERATOR 425#undef GENERAL_BINOP_FALLBACK 426 427// ---- Methods on Types ---- 428// FIXME: revamp to take TypeLoc's rather than Types. 429 430// Declare Traverse*() for all concrete Type classes. 431#define ABSTRACT_TYPE(CLASS, BASE) 432#define TYPE(CLASS, BASE) bool Traverse##CLASS##Type(CLASS##Type *T); 433#include "clang/AST/TypeNodes.def" 434 // The above header #undefs ABSTRACT_TYPE and TYPE upon exit. 435 436 // Define WalkUpFrom*() and empty Visit*() for all Type classes. 437 bool WalkUpFromType(Type *T) { return getDerived().VisitType(T); } 438 bool VisitType(Type *T) { return true; } 439#define TYPE(CLASS, BASE) \ 440 bool WalkUpFrom##CLASS##Type(CLASS##Type *T) { \ 441 TRY_TO(WalkUpFrom##BASE(T)); \ 442 TRY_TO(Visit##CLASS##Type(T)); \ 443 return true; \ 444 } \ 445 bool Visit##CLASS##Type(CLASS##Type *T) { return true; } 446#include "clang/AST/TypeNodes.def" 447 448// ---- Methods on TypeLocs ---- 449// FIXME: this currently just calls the matching Type methods 450 451// Declare Traverse*() for all concrete TypeLoc classes. 452#define ABSTRACT_TYPELOC(CLASS, BASE) 453#define TYPELOC(CLASS, BASE) bool Traverse##CLASS##TypeLoc(CLASS##TypeLoc TL); 454#include "clang/AST/TypeLocNodes.def" 455 // The above header #undefs ABSTRACT_TYPELOC and TYPELOC upon exit. 456 457 // Define WalkUpFrom*() and empty Visit*() for all TypeLoc classes. 458 bool WalkUpFromTypeLoc(TypeLoc TL) { return getDerived().VisitTypeLoc(TL); } 459 bool VisitTypeLoc(TypeLoc TL) { return true; } 460 461 // QualifiedTypeLoc and UnqualTypeLoc are not declared in 462 // TypeNodes.def and thus need to be handled specially. 463 bool WalkUpFromQualifiedTypeLoc(QualifiedTypeLoc TL) { 464 return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc()); 465 } 466 bool VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { return true; } 467 bool WalkUpFromUnqualTypeLoc(UnqualTypeLoc TL) { 468 return getDerived().VisitUnqualTypeLoc(TL.getUnqualifiedLoc()); 469 } 470 bool VisitUnqualTypeLoc(UnqualTypeLoc TL) { return true; } 471 472// Note that BASE includes trailing 'Type' which CLASS doesn't. 473#define TYPE(CLASS, BASE) \ 474 bool WalkUpFrom##CLASS##TypeLoc(CLASS##TypeLoc TL) { \ 475 TRY_TO(WalkUpFrom##BASE##Loc(TL)); \ 476 TRY_TO(Visit##CLASS##TypeLoc(TL)); \ 477 return true; \ 478 } \ 479 bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TL) { return true; } 480#include "clang/AST/TypeNodes.def" 481 482// ---- Methods on Decls ---- 483 484// Declare Traverse*() for all concrete Decl classes. 485#define ABSTRACT_DECL(DECL) 486#define DECL(CLASS, BASE) bool Traverse##CLASS##Decl(CLASS##Decl *D); 487#include "clang/AST/DeclNodes.inc" 488 // The above header #undefs ABSTRACT_DECL and DECL upon exit. 489 490 // Define WalkUpFrom*() and empty Visit*() for all Decl classes. 491 bool WalkUpFromDecl(Decl *D) { return getDerived().VisitDecl(D); } 492 bool VisitDecl(Decl *D) { return true; } 493#define DECL(CLASS, BASE) \ 494 bool WalkUpFrom##CLASS##Decl(CLASS##Decl *D) { \ 495 TRY_TO(WalkUpFrom##BASE(D)); \ 496 TRY_TO(Visit##CLASS##Decl(D)); \ 497 return true; \ 498 } \ 499 bool Visit##CLASS##Decl(CLASS##Decl *D) { return true; } 500#include "clang/AST/DeclNodes.inc" 501 502 bool canIgnoreChildDeclWhileTraversingDeclContext(const Decl *Child); 503 504private: 505 // These are helper methods used by more than one Traverse* method. 506 bool TraverseTemplateParameterListHelper(TemplateParameterList *TPL); 507 508 // Traverses template parameter lists of either a DeclaratorDecl or TagDecl. 509 template <typename T> 510 bool TraverseDeclTemplateParameterLists(T *D); 511 512#define DEF_TRAVERSE_TMPL_INST(TMPLDECLKIND) \ 513 bool TraverseTemplateInstantiations(TMPLDECLKIND##TemplateDecl *D); 514 DEF_TRAVERSE_TMPL_INST(Class) 515 DEF_TRAVERSE_TMPL_INST(Var) 516 DEF_TRAVERSE_TMPL_INST(Function) 517#undef DEF_TRAVERSE_TMPL_INST 518 bool TraverseTemplateArgumentLocsHelper(const TemplateArgumentLoc *TAL, 519 unsigned Count); 520 bool TraverseArrayTypeLocHelper(ArrayTypeLoc TL); 521 bool TraverseRecordHelper(RecordDecl *D); 522 bool TraverseCXXRecordHelper(CXXRecordDecl *D); 523 bool TraverseDeclaratorHelper(DeclaratorDecl *D); 524 bool TraverseDeclContextHelper(DeclContext *DC); 525 bool TraverseFunctionHelper(FunctionDecl *D); 526 bool TraverseVarHelper(VarDecl *D); 527 bool TraverseOMPExecutableDirective(OMPExecutableDirective *S); 528 bool TraverseOMPLoopDirective(OMPLoopDirective *S); 529 bool TraverseOMPClause(OMPClause *C); 530#define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C); 531#include "clang/Basic/OpenMPKinds.def" 532 /// \brief Process clauses with list of variables. 533 template <typename T> bool VisitOMPClauseList(T *Node); 534 /// Process clauses with pre-initis. 535 bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node); 536 bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node); 537 538 bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue); 539 bool PostVisitStmt(Stmt *S); 540}; 541 542template <typename Derived> 543bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S, 544 DataRecursionQueue *Queue) { 545#define DISPATCH_STMT(NAME, CLASS, VAR) \ 546 return TRAVERSE_STMT_BASE(NAME, CLASS, VAR, Queue); 547 548 // If we have a binary expr, dispatch to the subcode of the binop. A smart 549 // optimizer (e.g. LLVM) will fold this comparison into the switch stmt 550 // below. 551 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) { 552 switch (BinOp->getOpcode()) { 553#define OPERATOR(NAME) \ 554 case BO_##NAME: \ 555 DISPATCH_STMT(Bin##NAME, BinaryOperator, S); 556 557 BINOP_LIST() 558#undef OPERATOR 559#undef BINOP_LIST 560 561#define OPERATOR(NAME) \ 562 case BO_##NAME##Assign: \ 563 DISPATCH_STMT(Bin##NAME##Assign, CompoundAssignOperator, S); 564 565 CAO_LIST() 566#undef OPERATOR 567#undef CAO_LIST 568 } 569 } else if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(S)) { 570 switch (UnOp->getOpcode()) { 571#define OPERATOR(NAME) \ 572 case UO_##NAME: \ 573 DISPATCH_STMT(Unary##NAME, UnaryOperator, S); 574 575 UNARYOP_LIST() 576#undef OPERATOR 577#undef UNARYOP_LIST 578 } 579 } 580 581 // Top switch stmt: dispatch to TraverseFooStmt for each concrete FooStmt. 582 switch (S->getStmtClass()) { 583 case Stmt::NoStmtClass: 584 break; 585#define ABSTRACT_STMT(STMT) 586#define STMT(CLASS, PARENT) \ 587 case Stmt::CLASS##Class: \ 588 DISPATCH_STMT(CLASS, CLASS, S); 589#include "clang/AST/StmtNodes.inc" 590 } 591 592 return true; 593} 594 595#undef DISPATCH_STMT 596 597template <typename Derived> 598bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) { 599 switch (S->getStmtClass()) { 600 case Stmt::NoStmtClass: 601 break; 602#define ABSTRACT_STMT(STMT) 603#define STMT(CLASS, PARENT) \ 604 case Stmt::CLASS##Class: \ 605 TRY_TO(WalkUpFrom##CLASS(static_cast<CLASS *>(S))); break; 606#define INITLISTEXPR(CLASS, PARENT) \ 607 case Stmt::CLASS##Class: \ 608 { \ 609 auto ILE = static_cast<CLASS *>(S); \ 610 if (auto Syn = ILE->isSemanticForm() ? ILE->getSyntacticForm() : ILE) \ 611 TRY_TO(WalkUpFrom##CLASS(Syn)); \ 612 if (auto Sem = ILE->isSemanticForm() ? ILE : ILE->getSemanticForm()) \ 613 TRY_TO(WalkUpFrom##CLASS(Sem)); \ 614 break; \ 615 } 616#include "clang/AST/StmtNodes.inc" 617 } 618 619 return true; 620} 621 622#undef DISPATCH_STMT 623 624template <typename Derived> 625bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S, 626 DataRecursionQueue *Queue) { 627 if (!S) 628 return true; 629 630 if (Queue) { 631 Queue->push_back({S, false}); 632 return true; 633 } 634 635 SmallVector<llvm::PointerIntPair<Stmt *, 1, bool>, 8> LocalQueue; 636 LocalQueue.push_back({S, false}); 637 638 while (!LocalQueue.empty()) { 639 auto &CurrSAndVisited = LocalQueue.back(); 640 Stmt *CurrS = CurrSAndVisited.getPointer(); 641 bool Visited = CurrSAndVisited.getInt(); 642 if (Visited) { 643 LocalQueue.pop_back(); 644 TRY_TO(dataTraverseStmtPost(CurrS)); 645 if (getDerived().shouldTraversePostOrder()) { 646 TRY_TO(PostVisitStmt(CurrS)); 647 } 648 continue; 649 } 650 651 if (getDerived().dataTraverseStmtPre(CurrS)) { 652 CurrSAndVisited.setInt(true); 653 size_t N = LocalQueue.size(); 654 TRY_TO(dataTraverseNode(CurrS, &LocalQueue)); 655 // Process new children in the order they were added. 656 std::reverse(LocalQueue.begin() + N, LocalQueue.end()); 657 } else { 658 LocalQueue.pop_back(); 659 } 660 } 661 662 return true; 663} 664 665#define DISPATCH(NAME, CLASS, VAR) \ 666 return getDerived().Traverse##NAME(static_cast<CLASS *>(VAR)) 667 668template <typename Derived> 669bool RecursiveASTVisitor<Derived>::TraverseType(QualType T) { 670 if (T.isNull()) 671 return true; 672 673 switch (T->getTypeClass()) { 674#define ABSTRACT_TYPE(CLASS, BASE) 675#define TYPE(CLASS, BASE) \ 676 case Type::CLASS: \ 677 DISPATCH(CLASS##Type, CLASS##Type, const_cast<Type *>(T.getTypePtr())); 678#include "clang/AST/TypeNodes.def" 679 } 680 681 return true; 682} 683 684template <typename Derived> 685bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL) { 686 if (TL.isNull()) 687 return true; 688 689 switch (TL.getTypeLocClass()) { 690#define ABSTRACT_TYPELOC(CLASS, BASE) 691#define TYPELOC(CLASS, BASE) \ 692 case TypeLoc::CLASS: \ 693 return getDerived().Traverse##CLASS##TypeLoc(TL.castAs<CLASS##TypeLoc>()); 694#include "clang/AST/TypeLocNodes.def" 695 } 696 697 return true; 698} 699 700// Define the Traverse*Attr(Attr* A) methods 701#define VISITORCLASS RecursiveASTVisitor 702#include "clang/AST/AttrVisitor.inc" 703#undef VISITORCLASS 704 705template <typename Derived> 706bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) { 707 if (!D) 708 return true; 709 710 // As a syntax visitor, by default we want to ignore declarations for 711 // implicit declarations (ones not typed explicitly by the user). 712 if (!getDerived().shouldVisitImplicitCode() && D->isImplicit()) 713 return true; 714 715 switch (D->getKind()) { 716#define ABSTRACT_DECL(DECL) 717#define DECL(CLASS, BASE) \ 718 case Decl::CLASS: \ 719 if (!getDerived().Traverse##CLASS##Decl(static_cast<CLASS##Decl *>(D))) \ 720 return false; \ 721 break; 722#include "clang/AST/DeclNodes.inc" 723 } 724 725 // Visit any attributes attached to this declaration. 726 for (auto *I : D->attrs()) { 727 if (!getDerived().TraverseAttr(I)) 728 return false; 729 } 730 return true; 731} 732 733#undef DISPATCH 734 735template <typename Derived> 736bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier( 737 NestedNameSpecifier *NNS) { 738 if (!NNS) 739 return true; 740 741 if (NNS->getPrefix()) 742 TRY_TO(TraverseNestedNameSpecifier(NNS->getPrefix())); 743 744 switch (NNS->getKind()) { 745 case NestedNameSpecifier::Identifier: 746 case NestedNameSpecifier::Namespace: 747 case NestedNameSpecifier::NamespaceAlias: 748 case NestedNameSpecifier::Global: 749 case NestedNameSpecifier::Super: 750 return true; 751 752 case NestedNameSpecifier::TypeSpec: 753 case NestedNameSpecifier::TypeSpecWithTemplate: 754 TRY_TO(TraverseType(QualType(NNS->getAsType(), 0))); 755 } 756 757 return true; 758} 759 760template <typename Derived> 761bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc( 762 NestedNameSpecifierLoc NNS) { 763 if (!NNS) 764 return true; 765 766 if (NestedNameSpecifierLoc Prefix = NNS.getPrefix()) 767 TRY_TO(TraverseNestedNameSpecifierLoc(Prefix)); 768 769 switch (NNS.getNestedNameSpecifier()->getKind()) { 770 case NestedNameSpecifier::Identifier: 771 case NestedNameSpecifier::Namespace: 772 case NestedNameSpecifier::NamespaceAlias: 773 case NestedNameSpecifier::Global: 774 case NestedNameSpecifier::Super: 775 return true; 776 777 case NestedNameSpecifier::TypeSpec: 778 case NestedNameSpecifier::TypeSpecWithTemplate: 779 TRY_TO(TraverseTypeLoc(NNS.getTypeLoc())); 780 break; 781 } 782 783 return true; 784} 785 786template <typename Derived> 787bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo( 788 DeclarationNameInfo NameInfo) { 789 switch (NameInfo.getName().getNameKind()) { 790 case DeclarationName::CXXConstructorName: 791 case DeclarationName::CXXDestructorName: 792 case DeclarationName::CXXConversionFunctionName: 793 if (TypeSourceInfo *TSInfo = NameInfo.getNamedTypeInfo()) 794 TRY_TO(TraverseTypeLoc(TSInfo->getTypeLoc())); 795 break; 796 797 case DeclarationName::CXXDeductionGuideName: 798 TRY_TO(TraverseTemplateName( 799 TemplateName(NameInfo.getName().getCXXDeductionGuideTemplate()))); 800 break; 801 802 case DeclarationName::Identifier: 803 case DeclarationName::ObjCZeroArgSelector: 804 case DeclarationName::ObjCOneArgSelector: 805 case DeclarationName::ObjCMultiArgSelector: 806 case DeclarationName::CXXOperatorName: 807 case DeclarationName::CXXLiteralOperatorName: 808 case DeclarationName::CXXUsingDirective: 809 break; 810 } 811 812 return true; 813} 814 815template <typename Derived> 816bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) { 817 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) 818 TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier())); 819 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 820 TRY_TO(TraverseNestedNameSpecifier(QTN->getQualifier())); 821 822 return true; 823} 824 825template <typename Derived> 826bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument( 827 const TemplateArgument &Arg) { 828 switch (Arg.getKind()) { 829 case TemplateArgument::Null: 830 case TemplateArgument::Declaration: 831 case TemplateArgument::Integral: 832 case TemplateArgument::NullPtr: 833 return true; 834 835 case TemplateArgument::Type: 836 return getDerived().TraverseType(Arg.getAsType()); 837 838 case TemplateArgument::Template: 839 case TemplateArgument::TemplateExpansion: 840 return getDerived().TraverseTemplateName( 841 Arg.getAsTemplateOrTemplatePattern()); 842 843 case TemplateArgument::Expression: 844 return getDerived().TraverseStmt(Arg.getAsExpr()); 845 846 case TemplateArgument::Pack: 847 return getDerived().TraverseTemplateArguments(Arg.pack_begin(), 848 Arg.pack_size()); 849 } 850 851 return true; 852} 853 854// FIXME: no template name location? 855// FIXME: no source locations for a template argument pack? 856template <typename Derived> 857bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc( 858 const TemplateArgumentLoc &ArgLoc) { 859 const TemplateArgument &Arg = ArgLoc.getArgument(); 860 861 switch (Arg.getKind()) { 862 case TemplateArgument::Null: 863 case TemplateArgument::Declaration: 864 case TemplateArgument::Integral: 865 case TemplateArgument::NullPtr: 866 return true; 867 868 case TemplateArgument::Type: { 869 // FIXME: how can TSI ever be NULL? 870 if (TypeSourceInfo *TSI = ArgLoc.getTypeSourceInfo()) 871 return getDerived().TraverseTypeLoc(TSI->getTypeLoc()); 872 else 873 return getDerived().TraverseType(Arg.getAsType()); 874 } 875 876 case TemplateArgument::Template: 877 case TemplateArgument::TemplateExpansion: 878 if (ArgLoc.getTemplateQualifierLoc()) 879 TRY_TO(getDerived().TraverseNestedNameSpecifierLoc( 880 ArgLoc.getTemplateQualifierLoc())); 881 return getDerived().TraverseTemplateName( 882 Arg.getAsTemplateOrTemplatePattern()); 883 884 case TemplateArgument::Expression: 885 return getDerived().TraverseStmt(ArgLoc.getSourceExpression()); 886 887 case TemplateArgument::Pack: 888 return getDerived().TraverseTemplateArguments(Arg.pack_begin(), 889 Arg.pack_size()); 890 } 891 892 return true; 893} 894 895template <typename Derived> 896bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments( 897 const TemplateArgument *Args, unsigned NumArgs) { 898 for (unsigned I = 0; I != NumArgs; ++I) { 899 TRY_TO(TraverseTemplateArgument(Args[I])); 900 } 901 902 return true; 903} 904 905template <typename Derived> 906bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer( 907 CXXCtorInitializer *Init) { 908 if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo()) 909 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc())); 910 911 if (Init->isWritten() || getDerived().shouldVisitImplicitCode()) 912 TRY_TO(TraverseStmt(Init->getInit())); 913 914 return true; 915} 916 917template <typename Derived> 918bool 919RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr *LE, 920 const LambdaCapture *C, 921 Expr *Init) { 922 if (LE->isInitCapture(C)) 923 TRY_TO(TraverseDecl(C->getCapturedVar())); 924 else 925 TRY_TO(TraverseStmt(Init)); 926 return true; 927} 928 929template <typename Derived> 930bool RecursiveASTVisitor<Derived>::TraverseLambdaBody( 931 LambdaExpr *LE, DataRecursionQueue *Queue) { 932 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(LE->getBody()); 933 return true; 934} 935 936// ----------------- Type traversal ----------------- 937 938// This macro makes available a variable T, the passed-in type. 939#define DEF_TRAVERSE_TYPE(TYPE, CODE) \ 940 template <typename Derived> \ 941 bool RecursiveASTVisitor<Derived>::Traverse##TYPE(TYPE *T) { \ 942 if (!getDerived().shouldTraversePostOrder()) \ 943 TRY_TO(WalkUpFrom##TYPE(T)); \ 944 { CODE; } \ 945 if (getDerived().shouldTraversePostOrder()) \ 946 TRY_TO(WalkUpFrom##TYPE(T)); \ 947 return true; \ 948 } 949 950DEF_TRAVERSE_TYPE(BuiltinType, {}) 951 952DEF_TRAVERSE_TYPE(ComplexType, { TRY_TO(TraverseType(T->getElementType())); }) 953 954DEF_TRAVERSE_TYPE(PointerType, { TRY_TO(TraverseType(T->getPointeeType())); }) 955 956DEF_TRAVERSE_TYPE(BlockPointerType, 957 { TRY_TO(TraverseType(T->getPointeeType())); }) 958 959DEF_TRAVERSE_TYPE(LValueReferenceType, 960 { TRY_TO(TraverseType(T->getPointeeType())); }) 961 962DEF_TRAVERSE_TYPE(RValueReferenceType, 963 { TRY_TO(TraverseType(T->getPointeeType())); }) 964 965DEF_TRAVERSE_TYPE(MemberPointerType, { 966 TRY_TO(TraverseType(QualType(T->getClass(), 0))); 967 TRY_TO(TraverseType(T->getPointeeType())); 968}) 969 970DEF_TRAVERSE_TYPE(AdjustedType, { TRY_TO(TraverseType(T->getOriginalType())); }) 971 972DEF_TRAVERSE_TYPE(DecayedType, { TRY_TO(TraverseType(T->getOriginalType())); }) 973 974DEF_TRAVERSE_TYPE(ConstantArrayType, 975 { TRY_TO(TraverseType(T->getElementType())); }) 976 977DEF_TRAVERSE_TYPE(IncompleteArrayType, 978 { TRY_TO(TraverseType(T->getElementType())); }) 979 980DEF_TRAVERSE_TYPE(VariableArrayType, { 981 TRY_TO(TraverseType(T->getElementType())); 982 TRY_TO(TraverseStmt(T->getSizeExpr())); 983}) 984 985DEF_TRAVERSE_TYPE(DependentSizedArrayType, { 986 TRY_TO(TraverseType(T->getElementType())); 987 if (T->getSizeExpr()) 988 TRY_TO(TraverseStmt(T->getSizeExpr())); 989}) 990 991DEF_TRAVERSE_TYPE(DependentAddressSpaceType, { 992 TRY_TO(TraverseStmt(T->getAddrSpaceExpr())); 993 TRY_TO(TraverseType(T->getPointeeType())); 994}) 995 996DEF_TRAVERSE_TYPE(DependentSizedExtVectorType, { 997 if (T->getSizeExpr()) 998 TRY_TO(TraverseStmt(T->getSizeExpr())); 999 TRY_TO(TraverseType(T->getElementType())); 1000}) 1001 1002DEF_TRAVERSE_TYPE(VectorType, { TRY_TO(TraverseType(T->getElementType())); }) 1003 1004DEF_TRAVERSE_TYPE(ExtVectorType, { TRY_TO(TraverseType(T->getElementType())); }) 1005 1006DEF_TRAVERSE_TYPE(FunctionNoProtoType, 1007 { TRY_TO(TraverseType(T->getReturnType())); }) 1008 1009DEF_TRAVERSE_TYPE(FunctionProtoType, { 1010 TRY_TO(TraverseType(T->getReturnType())); 1011 1012 for (const auto &A : T->param_types()) { 1013 TRY_TO(TraverseType(A)); 1014 } 1015 1016 for (const auto &E : T->exceptions()) { 1017 TRY_TO(TraverseType(E)); 1018 } 1019 1020 if (Expr *NE = T->getNoexceptExpr()) 1021 TRY_TO(TraverseStmt(NE)); 1022}) 1023 1024DEF_TRAVERSE_TYPE(UnresolvedUsingType, {}) 1025DEF_TRAVERSE_TYPE(TypedefType, {}) 1026 1027DEF_TRAVERSE_TYPE(TypeOfExprType, 1028 { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); }) 1029 1030DEF_TRAVERSE_TYPE(TypeOfType, { TRY_TO(TraverseType(T->getUnderlyingType())); }) 1031 1032DEF_TRAVERSE_TYPE(DecltypeType, 1033 { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); }) 1034 1035DEF_TRAVERSE_TYPE(UnaryTransformType, { 1036 TRY_TO(TraverseType(T->getBaseType())); 1037 TRY_TO(TraverseType(T->getUnderlyingType())); 1038}) 1039 1040DEF_TRAVERSE_TYPE(AutoType, { TRY_TO(TraverseType(T->getDeducedType())); }) 1041DEF_TRAVERSE_TYPE(DeducedTemplateSpecializationType, { 1042 TRY_TO(TraverseTemplateName(T->getTemplateName())); 1043 TRY_TO(TraverseType(T->getDeducedType())); 1044}) 1045 1046DEF_TRAVERSE_TYPE(RecordType, {}) 1047DEF_TRAVERSE_TYPE(EnumType, {}) 1048DEF_TRAVERSE_TYPE(TemplateTypeParmType, {}) 1049DEF_TRAVERSE_TYPE(SubstTemplateTypeParmType, { 1050 TRY_TO(TraverseType(T->getReplacementType())); 1051}) 1052DEF_TRAVERSE_TYPE(SubstTemplateTypeParmPackType, { 1053 TRY_TO(TraverseTemplateArgument(T->getArgumentPack())); 1054}) 1055 1056DEF_TRAVERSE_TYPE(TemplateSpecializationType, { 1057 TRY_TO(TraverseTemplateName(T->getTemplateName())); 1058 TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs())); 1059}) 1060 1061DEF_TRAVERSE_TYPE(InjectedClassNameType, {}) 1062 1063DEF_TRAVERSE_TYPE(AttributedType, 1064 { TRY_TO(TraverseType(T->getModifiedType())); }) 1065 1066DEF_TRAVERSE_TYPE(ParenType, { TRY_TO(TraverseType(T->getInnerType())); }) 1067 1068DEF_TRAVERSE_TYPE(ElaboratedType, { 1069 if (T->getQualifier()) { 1070 TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); 1071 } 1072 TRY_TO(TraverseType(T->getNamedType())); 1073}) 1074 1075DEF_TRAVERSE_TYPE(DependentNameType, 1076 { TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); }) 1077 1078DEF_TRAVERSE_TYPE(DependentTemplateSpecializationType, { 1079 TRY_TO(TraverseNestedNameSpecifier(T->getQualifier())); 1080 TRY_TO(TraverseTemplateArguments(T->getArgs(), T->getNumArgs())); 1081}) 1082 1083DEF_TRAVERSE_TYPE(PackExpansionType, { TRY_TO(TraverseType(T->getPattern())); }) 1084 1085DEF_TRAVERSE_TYPE(ObjCTypeParamType, {}) 1086 1087DEF_TRAVERSE_TYPE(ObjCInterfaceType, {}) 1088 1089DEF_TRAVERSE_TYPE(ObjCObjectType, { 1090 // We have to watch out here because an ObjCInterfaceType's base 1091 // type is itself. 1092 if (T->getBaseType().getTypePtr() != T) 1093 TRY_TO(TraverseType(T->getBaseType())); 1094 for (auto typeArg : T->getTypeArgsAsWritten()) { 1095 TRY_TO(TraverseType(typeArg)); 1096 } 1097}) 1098 1099DEF_TRAVERSE_TYPE(ObjCObjectPointerType, 1100 { TRY_TO(TraverseType(T->getPointeeType())); }) 1101 1102DEF_TRAVERSE_TYPE(AtomicType, { TRY_TO(TraverseType(T->getValueType())); }) 1103 1104DEF_TRAVERSE_TYPE(PipeType, { TRY_TO(TraverseType(T->getElementType())); }) 1105 1106#undef DEF_TRAVERSE_TYPE 1107 1108// ----------------- TypeLoc traversal ----------------- 1109 1110// This macro makes available a variable TL, the passed-in TypeLoc. 1111// If requested, it calls WalkUpFrom* for the Type in the given TypeLoc, 1112// in addition to WalkUpFrom* for the TypeLoc itself, such that existing 1113// clients that override the WalkUpFrom*Type() and/or Visit*Type() methods 1114// continue to work. 1115#define DEF_TRAVERSE_TYPELOC(TYPE, CODE) \ 1116 template <typename Derived> \ 1117 bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) { \ 1118 if (getDerived().shouldWalkTypesOfTypeLocs()) \ 1119 TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE *>(TL.getTypePtr()))); \ 1120 TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \ 1121 { CODE; } \ 1122 return true; \ 1123 } 1124 1125template <typename Derived> 1126bool 1127RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(QualifiedTypeLoc TL) { 1128 // Move this over to the 'main' typeloc tree. Note that this is a 1129 // move -- we pretend that we were really looking at the unqualified 1130 // typeloc all along -- rather than a recursion, so we don't follow 1131 // the normal CRTP plan of going through 1132 // getDerived().TraverseTypeLoc. If we did, we'd be traversing 1133 // twice for the same type (once as a QualifiedTypeLoc version of 1134 // the type, once as an UnqualifiedTypeLoc version of the type), 1135 // which in effect means we'd call VisitTypeLoc twice with the 1136 // 'same' type. This solves that problem, at the cost of never 1137 // seeing the qualified version of the type (unless the client 1138 // subclasses TraverseQualifiedTypeLoc themselves). It's not a 1139 // perfect solution. A perfect solution probably requires making 1140 // QualifiedTypeLoc a wrapper around TypeLoc -- like QualType is a 1141 // wrapper around Type* -- rather than being its own class in the 1142 // type hierarchy. 1143 return TraverseTypeLoc(TL.getUnqualifiedLoc()); 1144} 1145 1146DEF_TRAVERSE_TYPELOC(BuiltinType, {}) 1147 1148// FIXME: ComplexTypeLoc is unfinished 1149DEF_TRAVERSE_TYPELOC(ComplexType, { 1150 TRY_TO(TraverseType(TL.getTypePtr()->getElementType())); 1151}) 1152 1153DEF_TRAVERSE_TYPELOC(PointerType, 1154 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); }) 1155 1156DEF_TRAVERSE_TYPELOC(BlockPointerType, 1157 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); }) 1158 1159DEF_TRAVERSE_TYPELOC(LValueReferenceType, 1160 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); }) 1161 1162DEF_TRAVERSE_TYPELOC(RValueReferenceType, 1163 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); }) 1164 1165// FIXME: location of base class? 1166// We traverse this in the type case as well, but how is it not reached through 1167// the pointee type? 1168DEF_TRAVERSE_TYPELOC(MemberPointerType, { 1169 TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0))); 1170 TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); 1171}) 1172 1173DEF_TRAVERSE_TYPELOC(AdjustedType, 1174 { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); }) 1175 1176DEF_TRAVERSE_TYPELOC(DecayedType, 1177 { TRY_TO(TraverseTypeLoc(TL.getOriginalLoc())); }) 1178 1179template <typename Derived> 1180bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) { 1181 // This isn't available for ArrayType, but is for the ArrayTypeLoc. 1182 TRY_TO(TraverseStmt(TL.getSizeExpr())); 1183 return true; 1184} 1185 1186DEF_TRAVERSE_TYPELOC(ConstantArrayType, { 1187 TRY_TO(TraverseTypeLoc(TL.getElementLoc())); 1188 return TraverseArrayTypeLocHelper(TL); 1189}) 1190 1191DEF_TRAVERSE_TYPELOC(IncompleteArrayType, { 1192 TRY_TO(TraverseTypeLoc(TL.getElementLoc())); 1193 return TraverseArrayTypeLocHelper(TL); 1194}) 1195 1196DEF_TRAVERSE_TYPELOC(VariableArrayType, { 1197 TRY_TO(TraverseTypeLoc(TL.getElementLoc())); 1198 return TraverseArrayTypeLocHelper(TL); 1199}) 1200 1201DEF_TRAVERSE_TYPELOC(DependentSizedArrayType, { 1202 TRY_TO(TraverseTypeLoc(TL.getElementLoc())); 1203 return TraverseArrayTypeLocHelper(TL); 1204}) 1205 1206DEF_TRAVERSE_TYPELOC(DependentAddressSpaceType, { 1207 TRY_TO(TraverseStmt(TL.getTypePtr()->getAddrSpaceExpr())); 1208 TRY_TO(TraverseType(TL.getTypePtr()->getPointeeType())); 1209}) 1210 1211// FIXME: order? why not size expr first? 1212// FIXME: base VectorTypeLoc is unfinished 1213DEF_TRAVERSE_TYPELOC(DependentSizedExtVectorType, { 1214 if (TL.getTypePtr()->getSizeExpr()) 1215 TRY_TO(TraverseStmt(TL.getTypePtr()->getSizeExpr())); 1216 TRY_TO(TraverseType(TL.getTypePtr()->getElementType())); 1217}) 1218 1219// FIXME: VectorTypeLoc is unfinished 1220DEF_TRAVERSE_TYPELOC(VectorType, { 1221 TRY_TO(TraverseType(TL.getTypePtr()->getElementType())); 1222}) 1223 1224// FIXME: size and attributes 1225// FIXME: base VectorTypeLoc is unfinished 1226DEF_TRAVERSE_TYPELOC(ExtVectorType, { 1227 TRY_TO(TraverseType(TL.getTypePtr()->getElementType())); 1228}) 1229 1230DEF_TRAVERSE_TYPELOC(FunctionNoProtoType, 1231 { TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); }) 1232 1233// FIXME: location of exception specifications (attributes?) 1234DEF_TRAVERSE_TYPELOC(FunctionProtoType, { 1235 TRY_TO(TraverseTypeLoc(TL.getReturnLoc())); 1236 1237 const FunctionProtoType *T = TL.getTypePtr(); 1238 1239 for (unsigned I = 0, E = TL.getNumParams(); I != E; ++I) { 1240 if (TL.getParam(I)) { 1241 TRY_TO(TraverseDecl(TL.getParam(I))); 1242 } else if (I < T->getNumParams()) { 1243 TRY_TO(TraverseType(T->getParamType(I))); 1244 } 1245 } 1246 1247 for (const auto &E : T->exceptions()) { 1248 TRY_TO(TraverseType(E)); 1249 } 1250 1251 if (Expr *NE = T->getNoexceptExpr()) 1252 TRY_TO(TraverseStmt(NE)); 1253}) 1254 1255DEF_TRAVERSE_TYPELOC(UnresolvedUsingType, {}) 1256DEF_TRAVERSE_TYPELOC(TypedefType, {}) 1257 1258DEF_TRAVERSE_TYPELOC(TypeOfExprType, 1259 { TRY_TO(TraverseStmt(TL.getUnderlyingExpr())); }) 1260 1261DEF_TRAVERSE_TYPELOC(TypeOfType, { 1262 TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())); 1263}) 1264 1265// FIXME: location of underlying expr 1266DEF_TRAVERSE_TYPELOC(DecltypeType, { 1267 TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr())); 1268}) 1269 1270DEF_TRAVERSE_TYPELOC(UnaryTransformType, { 1271 TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc())); 1272}) 1273 1274DEF_TRAVERSE_TYPELOC(AutoType, { 1275 TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType())); 1276}) 1277 1278DEF_TRAVERSE_TYPELOC(DeducedTemplateSpecializationType, { 1279 TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName())); 1280 TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType())); 1281}) 1282 1283DEF_TRAVERSE_TYPELOC(RecordType, {}) 1284DEF_TRAVERSE_TYPELOC(EnumType, {}) 1285DEF_TRAVERSE_TYPELOC(TemplateTypeParmType, {}) 1286DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmType, { 1287 TRY_TO(TraverseType(TL.getTypePtr()->getReplacementType())); 1288}) 1289DEF_TRAVERSE_TYPELOC(SubstTemplateTypeParmPackType, { 1290 TRY_TO(TraverseTemplateArgument(TL.getTypePtr()->getArgumentPack())); 1291}) 1292 1293// FIXME: use the loc for the template name? 1294DEF_TRAVERSE_TYPELOC(TemplateSpecializationType, { 1295 TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName())); 1296 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { 1297 TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I))); 1298 } 1299}) 1300 1301DEF_TRAVERSE_TYPELOC(InjectedClassNameType, {}) 1302 1303DEF_TRAVERSE_TYPELOC(ParenType, { TRY_TO(TraverseTypeLoc(TL.getInnerLoc())); }) 1304 1305DEF_TRAVERSE_TYPELOC(AttributedType, 1306 { TRY_TO(TraverseTypeLoc(TL.getModifiedLoc())); }) 1307 1308DEF_TRAVERSE_TYPELOC(ElaboratedType, { 1309 if (TL.getQualifierLoc()) { 1310 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())); 1311 } 1312 TRY_TO(TraverseTypeLoc(TL.getNamedTypeLoc())); 1313}) 1314 1315DEF_TRAVERSE_TYPELOC(DependentNameType, { 1316 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())); 1317}) 1318 1319DEF_TRAVERSE_TYPELOC(DependentTemplateSpecializationType, { 1320 if (TL.getQualifierLoc()) { 1321 TRY_TO(TraverseNestedNameSpecifierLoc(TL.getQualifierLoc())); 1322 } 1323 1324 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) { 1325 TRY_TO(TraverseTemplateArgumentLoc(TL.getArgLoc(I))); 1326 } 1327}) 1328 1329DEF_TRAVERSE_TYPELOC(PackExpansionType, 1330 { TRY_TO(TraverseTypeLoc(TL.getPatternLoc())); }) 1331 1332DEF_TRAVERSE_TYPELOC(ObjCTypeParamType, {}) 1333 1334DEF_TRAVERSE_TYPELOC(ObjCInterfaceType, {}) 1335 1336DEF_TRAVERSE_TYPELOC(ObjCObjectType, { 1337 // We have to watch out here because an ObjCInterfaceType's base 1338 // type is itself. 1339 if (TL.getTypePtr()->getBaseType().getTypePtr() != TL.getTypePtr()) 1340 TRY_TO(TraverseTypeLoc(TL.getBaseLoc())); 1341 for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) 1342 TRY_TO(TraverseTypeLoc(TL.getTypeArgTInfo(i)->getTypeLoc())); 1343}) 1344 1345DEF_TRAVERSE_TYPELOC(ObjCObjectPointerType, 1346 { TRY_TO(TraverseTypeLoc(TL.getPointeeLoc())); }) 1347 1348DEF_TRAVERSE_TYPELOC(AtomicType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc())); }) 1349 1350DEF_TRAVERSE_TYPELOC(PipeType, { TRY_TO(TraverseTypeLoc(TL.getValueLoc())); }) 1351 1352#undef DEF_TRAVERSE_TYPELOC 1353 1354// ----------------- Decl traversal ----------------- 1355// 1356// For a Decl, we automate (in the DEF_TRAVERSE_DECL macro) traversing 1357// the children that come from the DeclContext associated with it. 1358// Therefore each Traverse* only needs to worry about children other 1359// than those. 1360 1361template <typename Derived> 1362bool RecursiveASTVisitor<Derived>::canIgnoreChildDeclWhileTraversingDeclContext( 1363 const Decl *Child) { 1364 // BlockDecls and CapturedDecls are traversed through BlockExprs and 1365 // CapturedStmts respectively. 1366 return isa<BlockDecl>(Child) || isa<CapturedDecl>(Child); 1367} 1368 1369template <typename Derived> 1370bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) { 1371 if (!DC) 1372 return true; 1373 1374 for (auto *Child : DC->decls()) { 1375 if (!canIgnoreChildDeclWhileTraversingDeclContext(Child)) 1376 TRY_TO(TraverseDecl(Child)); 1377 } 1378 1379 return true; 1380} 1381 1382// This macro makes available a variable D, the passed-in decl. 1383#define DEF_TRAVERSE_DECL(DECL, CODE) \ 1384 template <typename Derived> \ 1385 bool RecursiveASTVisitor<Derived>::Traverse##DECL(DECL *D) { \ 1386 bool ShouldVisitChildren = true; \ 1387 bool ReturnValue = true; \ 1388 if (!getDerived().shouldTraversePostOrder()) \ 1389 TRY_TO(WalkUpFrom##DECL(D)); \ 1390 { CODE; } \ 1391 if (ReturnValue && ShouldVisitChildren) \ 1392 TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D))); \ 1393 if (ReturnValue && getDerived().shouldTraversePostOrder()) \ 1394 TRY_TO(WalkUpFrom##DECL(D)); \ 1395 return ReturnValue; \ 1396 } 1397 1398DEF_TRAVERSE_DECL(AccessSpecDecl, {}) 1399 1400DEF_TRAVERSE_DECL(BlockDecl, { 1401 if (TypeSourceInfo *TInfo = D->getSignatureAsWritten()) 1402 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc())); 1403 TRY_TO(TraverseStmt(D->getBody())); 1404 for (const auto &I : D->captures()) { 1405 if (I.hasCopyExpr()) { 1406 TRY_TO(TraverseStmt(I.getCopyExpr())); 1407 } 1408 } 1409 ShouldVisitChildren = false; 1410}) 1411 1412DEF_TRAVERSE_DECL(CapturedDecl, { 1413 TRY_TO(TraverseStmt(D->getBody())); 1414 ShouldVisitChildren = false; 1415}) 1416 1417DEF_TRAVERSE_DECL(EmptyDecl, {}) 1418 1419DEF_TRAVERSE_DECL(FileScopeAsmDecl, 1420 { TRY_TO(TraverseStmt(D->getAsmString())); }) 1421 1422DEF_TRAVERSE_DECL(ImportDecl, {}) 1423 1424DEF_TRAVERSE_DECL(FriendDecl, { 1425 // Friend is either decl or a type. 1426 if (D->getFriendType()) 1427 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc())); 1428 else 1429 TRY_TO(TraverseDecl(D->getFriendDecl())); 1430}) 1431 1432DEF_TRAVERSE_DECL(FriendTemplateDecl, { 1433 if (D->getFriendType()) 1434 TRY_TO(TraverseTypeLoc(D->getFriendType()->getTypeLoc())); 1435 else 1436 TRY_TO(TraverseDecl(D->getFriendDecl())); 1437 for (unsigned I = 0, E = D->getNumTemplateParameters(); I < E; ++I) { 1438 TemplateParameterList *TPL = D->getTemplateParameterList(I); 1439 for (TemplateParameterList::iterator ITPL = TPL->begin(), ETPL = TPL->end(); 1440 ITPL != ETPL; ++ITPL) { 1441 TRY_TO(TraverseDecl(*ITPL)); 1442 } 1443 } 1444}) 1445 1446DEF_TRAVERSE_DECL(ClassScopeFunctionSpecializationDecl, { 1447 TRY_TO(TraverseDecl(D->getSpecialization())); 1448 1449 if (D->hasExplicitTemplateArgs()) { 1450 const TemplateArgumentListInfo &args = D->templateArgs(); 1451 TRY_TO(TraverseTemplateArgumentLocsHelper(args.getArgumentArray(), 1452 args.size())); 1453 } 1454}) 1455 1456DEF_TRAVERSE_DECL(LinkageSpecDecl, {}) 1457 1458DEF_TRAVERSE_DECL(ExportDecl, {}) 1459 1460DEF_TRAVERSE_DECL(ObjCPropertyImplDecl, {// FIXME: implement this 1461 }) 1462 1463DEF_TRAVERSE_DECL(StaticAssertDecl, { 1464 TRY_TO(TraverseStmt(D->getAssertExpr())); 1465 TRY_TO(TraverseStmt(D->getMessage())); 1466}) 1467 1468DEF_TRAVERSE_DECL( 1469 TranslationUnitDecl, 1470 {// Code in an unnamed namespace shows up automatically in 1471 // decls_begin()/decls_end(). Thus we don't need to recurse on 1472 // D->getAnonymousNamespace(). 1473 }) 1474 1475DEF_TRAVERSE_DECL(PragmaCommentDecl, {}) 1476 1477DEF_TRAVERSE_DECL(PragmaDetectMismatchDecl, {}) 1478 1479DEF_TRAVERSE_DECL(ExternCContextDecl, {}) 1480 1481DEF_TRAVERSE_DECL(NamespaceAliasDecl, { 1482 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1483 1484 // We shouldn't traverse an aliased namespace, since it will be 1485 // defined (and, therefore, traversed) somewhere else. 1486 ShouldVisitChildren = false; 1487}) 1488 1489DEF_TRAVERSE_DECL(LabelDecl, {// There is no code in a LabelDecl. 1490 }) 1491 1492DEF_TRAVERSE_DECL( 1493 NamespaceDecl, 1494 {// Code in an unnamed namespace shows up automatically in 1495 // decls_begin()/decls_end(). Thus we don't need to recurse on 1496 // D->getAnonymousNamespace(). 1497 }) 1498 1499DEF_TRAVERSE_DECL(ObjCCompatibleAliasDecl, {// FIXME: implement 1500 }) 1501 1502DEF_TRAVERSE_DECL(ObjCCategoryDecl, {// FIXME: implement 1503 if (ObjCTypeParamList *typeParamList = D->getTypeParamList()) { 1504 for (auto typeParam : *typeParamList) { 1505 TRY_TO(TraverseObjCTypeParamDecl(typeParam)); 1506 } 1507 } 1508}) 1509 1510DEF_TRAVERSE_DECL(ObjCCategoryImplDecl, {// FIXME: implement 1511 }) 1512 1513DEF_TRAVERSE_DECL(ObjCImplementationDecl, {// FIXME: implement 1514 }) 1515 1516DEF_TRAVERSE_DECL(ObjCInterfaceDecl, {// FIXME: implement 1517 if (ObjCTypeParamList *typeParamList = D->getTypeParamListAsWritten()) { 1518 for (auto typeParam : *typeParamList) { 1519 TRY_TO(TraverseObjCTypeParamDecl(typeParam)); 1520 } 1521 } 1522 1523 if (TypeSourceInfo *superTInfo = D->getSuperClassTInfo()) { 1524 TRY_TO(TraverseTypeLoc(superTInfo->getTypeLoc())); 1525 } 1526}) 1527 1528DEF_TRAVERSE_DECL(ObjCProtocolDecl, {// FIXME: implement 1529 }) 1530 1531DEF_TRAVERSE_DECL(ObjCMethodDecl, { 1532 if (D->getReturnTypeSourceInfo()) { 1533 TRY_TO(TraverseTypeLoc(D->getReturnTypeSourceInfo()->getTypeLoc())); 1534 } 1535 for (ParmVarDecl *Parameter : D->parameters()) { 1536 TRY_TO(TraverseDecl(Parameter)); 1537 } 1538 if (D->isThisDeclarationADefinition()) { 1539 TRY_TO(TraverseStmt(D->getBody())); 1540 } 1541 ShouldVisitChildren = false; 1542}) 1543 1544DEF_TRAVERSE_DECL(ObjCTypeParamDecl, { 1545 if (D->hasExplicitBound()) { 1546 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())); 1547 // We shouldn't traverse D->getTypeForDecl(); it's a result of 1548 // declaring the type alias, not something that was written in the 1549 // source. 1550 } 1551}) 1552 1553DEF_TRAVERSE_DECL(ObjCPropertyDecl, { 1554 if (D->getTypeSourceInfo()) 1555 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())); 1556 else 1557 TRY_TO(TraverseType(D->getType())); 1558 ShouldVisitChildren = false; 1559}) 1560 1561DEF_TRAVERSE_DECL(UsingDecl, { 1562 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1563 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo())); 1564}) 1565 1566DEF_TRAVERSE_DECL(UsingPackDecl, {}) 1567 1568DEF_TRAVERSE_DECL(UsingDirectiveDecl, { 1569 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1570}) 1571 1572DEF_TRAVERSE_DECL(UsingShadowDecl, {}) 1573 1574DEF_TRAVERSE_DECL(ConstructorUsingShadowDecl, {}) 1575 1576DEF_TRAVERSE_DECL(OMPThreadPrivateDecl, { 1577 for (auto *I : D->varlists()) { 1578 TRY_TO(TraverseStmt(I)); 1579 } 1580}) 1581 1582DEF_TRAVERSE_DECL(OMPDeclareReductionDecl, { 1583 TRY_TO(TraverseStmt(D->getCombiner())); 1584 if (auto *Initializer = D->getInitializer()) 1585 TRY_TO(TraverseStmt(Initializer)); 1586 TRY_TO(TraverseType(D->getType())); 1587 return true; 1588}) 1589 1590DEF_TRAVERSE_DECL(OMPCapturedExprDecl, { TRY_TO(TraverseVarHelper(D)); }) 1591 1592// A helper method for TemplateDecl's children. 1593template <typename Derived> 1594bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper( 1595 TemplateParameterList *TPL) { 1596 if (TPL) { 1597 for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); 1598 I != E; ++I) { 1599 TRY_TO(TraverseDecl(*I)); 1600 } 1601 } 1602 return true; 1603} 1604 1605template <typename Derived> 1606template <typename T> 1607bool RecursiveASTVisitor<Derived>::TraverseDeclTemplateParameterLists(T *D) { 1608 for (unsigned i = 0; i < D->getNumTemplateParameterLists(); i++) { 1609 TemplateParameterList *TPL = D->getTemplateParameterList(i); 1610 TraverseTemplateParameterListHelper(TPL); 1611 } 1612 return true; 1613} 1614 1615template <typename Derived> 1616bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( 1617 ClassTemplateDecl *D) { 1618 for (auto *SD : D->specializations()) { 1619 for (auto *RD : SD->redecls()) { 1620 // We don't want to visit injected-class-names in this traversal. 1621 if (cast<CXXRecordDecl>(RD)->isInjectedClassName()) 1622 continue; 1623 1624 switch ( 1625 cast<ClassTemplateSpecializationDecl>(RD)->getSpecializationKind()) { 1626 // Visit the implicit instantiations with the requested pattern. 1627 case TSK_Undeclared: 1628 case TSK_ImplicitInstantiation: 1629 TRY_TO(TraverseDecl(RD)); 1630 break; 1631 1632 // We don't need to do anything on an explicit instantiation 1633 // or explicit specialization because there will be an explicit 1634 // node for it elsewhere. 1635 case TSK_ExplicitInstantiationDeclaration: 1636 case TSK_ExplicitInstantiationDefinition: 1637 case TSK_ExplicitSpecialization: 1638 break; 1639 } 1640 } 1641 } 1642 1643 return true; 1644} 1645 1646template <typename Derived> 1647bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( 1648 VarTemplateDecl *D) { 1649 for (auto *SD : D->specializations()) { 1650 for (auto *RD : SD->redecls()) { 1651 switch ( 1652 cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) { 1653 case TSK_Undeclared: 1654 case TSK_ImplicitInstantiation: 1655 TRY_TO(TraverseDecl(RD)); 1656 break; 1657 1658 case TSK_ExplicitInstantiationDeclaration: 1659 case TSK_ExplicitInstantiationDefinition: 1660 case TSK_ExplicitSpecialization: 1661 break; 1662 } 1663 } 1664 } 1665 1666 return true; 1667} 1668 1669// A helper method for traversing the instantiations of a 1670// function while skipping its specializations. 1671template <typename Derived> 1672bool RecursiveASTVisitor<Derived>::TraverseTemplateInstantiations( 1673 FunctionTemplateDecl *D) { 1674 for (auto *FD : D->specializations()) { 1675 for (auto *RD : FD->redecls()) { 1676 switch (RD->getTemplateSpecializationKind()) { 1677 case TSK_Undeclared: 1678 case TSK_ImplicitInstantiation: 1679 // We don't know what kind of FunctionDecl this is. 1680 TRY_TO(TraverseDecl(RD)); 1681 break; 1682 1683 // FIXME: For now traverse explicit instantiations here. Change that 1684 // once they are represented as dedicated nodes in the AST. 1685 case TSK_ExplicitInstantiationDeclaration: 1686 case TSK_ExplicitInstantiationDefinition: 1687 TRY_TO(TraverseDecl(RD)); 1688 break; 1689 1690 case TSK_ExplicitSpecialization: 1691 break; 1692 } 1693 } 1694 } 1695 1696 return true; 1697} 1698 1699// This macro unifies the traversal of class, variable and function 1700// template declarations. 1701#define DEF_TRAVERSE_TMPL_DECL(TMPLDECLKIND) \ 1702 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateDecl, { \ 1703 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); \ 1704 TRY_TO(TraverseDecl(D->getTemplatedDecl())); \ 1705 \ 1706 /* By default, we do not traverse the instantiations of \ 1707 class templates since they do not appear in the user code. The \ 1708 following code optionally traverses them. \ 1709 \ 1710 We only traverse the class instantiations when we see the canonical \ 1711 declaration of the template, to ensure we only visit them once. */ \ 1712 if (getDerived().shouldVisitTemplateInstantiations() && \ 1713 D == D->getCanonicalDecl()) \ 1714 TRY_TO(TraverseTemplateInstantiations(D)); \ 1715 \ 1716 /* Note that getInstantiatedFromMemberTemplate() is just a link \ 1717 from a template instantiation back to the template from which \ 1718 it was instantiated, and thus should not be traversed. */ \ 1719 }) 1720 1721DEF_TRAVERSE_TMPL_DECL(Class) 1722DEF_TRAVERSE_TMPL_DECL(Var) 1723DEF_TRAVERSE_TMPL_DECL(Function) 1724 1725DEF_TRAVERSE_DECL(TemplateTemplateParmDecl, { 1726 // D is the "T" in something like 1727 // template <template <typename> class T> class container { }; 1728 TRY_TO(TraverseDecl(D->getTemplatedDecl())); 1729 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) { 1730 TRY_TO(TraverseTemplateArgumentLoc(D->getDefaultArgument())); 1731 } 1732 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); 1733}) 1734 1735DEF_TRAVERSE_DECL(BuiltinTemplateDecl, { 1736 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); 1737}) 1738 1739DEF_TRAVERSE_DECL(TemplateTypeParmDecl, { 1740 // D is the "T" in something like "template<typename T> class vector;" 1741 if (D->getTypeForDecl()) 1742 TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0))); 1743 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 1744 TRY_TO(TraverseTypeLoc(D->getDefaultArgumentInfo()->getTypeLoc())); 1745}) 1746 1747DEF_TRAVERSE_DECL(TypedefDecl, { 1748 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())); 1749 // We shouldn't traverse D->getTypeForDecl(); it's a result of 1750 // declaring the typedef, not something that was written in the 1751 // source. 1752}) 1753 1754DEF_TRAVERSE_DECL(TypeAliasDecl, { 1755 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())); 1756 // We shouldn't traverse D->getTypeForDecl(); it's a result of 1757 // declaring the type alias, not something that was written in the 1758 // source. 1759}) 1760 1761DEF_TRAVERSE_DECL(TypeAliasTemplateDecl, { 1762 TRY_TO(TraverseDecl(D->getTemplatedDecl())); 1763 TRY_TO(TraverseTemplateParameterListHelper(D->getTemplateParameters())); 1764}) 1765 1766DEF_TRAVERSE_DECL(UnresolvedUsingTypenameDecl, { 1767 // A dependent using declaration which was marked with 'typename'. 1768 // template<class T> class A : public B<T> { using typename B<T>::foo; }; 1769 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1770 // We shouldn't traverse D->getTypeForDecl(); it's a result of 1771 // declaring the type, not something that was written in the 1772 // source. 1773}) 1774 1775DEF_TRAVERSE_DECL(EnumDecl, { 1776 TRY_TO(TraverseDeclTemplateParameterLists(D)); 1777 1778 if (D->getTypeForDecl()) 1779 TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0))); 1780 1781 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1782 // The enumerators are already traversed by 1783 // decls_begin()/decls_end(). 1784}) 1785 1786// Helper methods for RecordDecl and its children. 1787template <typename Derived> 1788bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) { 1789 // We shouldn't traverse D->getTypeForDecl(); it's a result of 1790 // declaring the type, not something that was written in the source. 1791 1792 TRY_TO(TraverseDeclTemplateParameterLists(D)); 1793 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1794 return true; 1795} 1796 1797template <typename Derived> 1798bool RecursiveASTVisitor<Derived>::TraverseCXXBaseSpecifier( 1799 const CXXBaseSpecifier &Base) { 1800 TRY_TO(TraverseTypeLoc(Base.getTypeSourceInfo()->getTypeLoc())); 1801 return true; 1802} 1803 1804template <typename Derived> 1805bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(CXXRecordDecl *D) { 1806 if (!TraverseRecordHelper(D)) 1807 return false; 1808 if (D->isCompleteDefinition()) { 1809 for (const auto &I : D->bases()) { 1810 TRY_TO(TraverseCXXBaseSpecifier(I)); 1811 } 1812 // We don't traverse the friends or the conversions, as they are 1813 // already in decls_begin()/decls_end(). 1814 } 1815 return true; 1816} 1817 1818DEF_TRAVERSE_DECL(RecordDecl, { TRY_TO(TraverseRecordHelper(D)); }) 1819 1820DEF_TRAVERSE_DECL(CXXRecordDecl, { TRY_TO(TraverseCXXRecordHelper(D)); }) 1821 1822#define DEF_TRAVERSE_TMPL_SPEC_DECL(TMPLDECLKIND) \ 1823 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplateSpecializationDecl, { \ 1824 /* For implicit instantiations ("set<int> x;"), we don't want to \ 1825 recurse at all, since the instatiated template isn't written in \ 1826 the source code anywhere. (Note the instatiated *type* -- \ 1827 set<int> -- is written, and will still get a callback of \ 1828 TemplateSpecializationType). For explicit instantiations \ 1829 ("template set<int>;"), we do need a callback, since this \ 1830 is the only callback that's made for this instantiation. \ 1831 We use getTypeAsWritten() to distinguish. */ \ 1832 if (TypeSourceInfo *TSI = D->getTypeAsWritten()) \ 1833 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc())); \ 1834 \ 1835 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); \ 1836 if (!getDerived().shouldVisitTemplateInstantiations() && \ 1837 D->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) \ 1838 /* Returning from here skips traversing the \ 1839 declaration context of the *TemplateSpecializationDecl \ 1840 (embedded in the DEF_TRAVERSE_DECL() macro) \ 1841 which contains the instantiated members of the template. */ \ 1842 return true; \ 1843 }) 1844 1845DEF_TRAVERSE_TMPL_SPEC_DECL(Class) 1846DEF_TRAVERSE_TMPL_SPEC_DECL(Var) 1847 1848template <typename Derived> 1849bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper( 1850 const TemplateArgumentLoc *TAL, unsigned Count) { 1851 for (unsigned I = 0; I < Count; ++I) { 1852 TRY_TO(TraverseTemplateArgumentLoc(TAL[I])); 1853 } 1854 return true; 1855} 1856 1857#define DEF_TRAVERSE_TMPL_PART_SPEC_DECL(TMPLDECLKIND, DECLKIND) \ 1858 DEF_TRAVERSE_DECL(TMPLDECLKIND##TemplatePartialSpecializationDecl, { \ 1859 /* The partial specialization. */ \ 1860 if (TemplateParameterList *TPL = D->getTemplateParameters()) { \ 1861 for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end(); \ 1862 I != E; ++I) { \ 1863 TRY_TO(TraverseDecl(*I)); \ 1864 } \ 1865 } \ 1866 /* The args that remains unspecialized. */ \ 1867 TRY_TO(TraverseTemplateArgumentLocsHelper( \ 1868 D->getTemplateArgsAsWritten()->getTemplateArgs(), \ 1869 D->getTemplateArgsAsWritten()->NumTemplateArgs)); \ 1870 \ 1871 /* Don't need the *TemplatePartialSpecializationHelper, even \ 1872 though that's our parent class -- we already visit all the \ 1873 template args here. */ \ 1874 TRY_TO(Traverse##DECLKIND##Helper(D)); \ 1875 \ 1876 /* Instantiations will have been visited with the primary template. */ \ 1877 }) 1878 1879DEF_TRAVERSE_TMPL_PART_SPEC_DECL(Class, CXXRecord) 1880DEF_TRAVERSE_TMPL_PART_SPEC_DECL(Var, Var) 1881 1882DEF_TRAVERSE_DECL(EnumConstantDecl, { TRY_TO(TraverseStmt(D->getInitExpr())); }) 1883 1884DEF_TRAVERSE_DECL(UnresolvedUsingValueDecl, { 1885 // Like UnresolvedUsingTypenameDecl, but without the 'typename': 1886 // template <class T> Class A : public Base<T> { using Base<T>::foo; }; 1887 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1888 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo())); 1889}) 1890 1891DEF_TRAVERSE_DECL(IndirectFieldDecl, {}) 1892 1893template <typename Derived> 1894bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) { 1895 TRY_TO(TraverseDeclTemplateParameterLists(D)); 1896 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1897 if (D->getTypeSourceInfo()) 1898 TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc())); 1899 else 1900 TRY_TO(TraverseType(D->getType())); 1901 return true; 1902} 1903 1904DEF_TRAVERSE_DECL(DecompositionDecl, { 1905 TRY_TO(TraverseVarHelper(D)); 1906 for (auto *Binding : D->bindings()) { 1907 TRY_TO(TraverseDecl(Binding)); 1908 } 1909}) 1910 1911DEF_TRAVERSE_DECL(BindingDecl, { 1912 if (getDerived().shouldVisitImplicitCode()) 1913 TRY_TO(TraverseStmt(D->getBinding())); 1914}) 1915 1916DEF_TRAVERSE_DECL(MSPropertyDecl, { TRY_TO(TraverseDeclaratorHelper(D)); }) 1917 1918DEF_TRAVERSE_DECL(FieldDecl, { 1919 TRY_TO(TraverseDeclaratorHelper(D)); 1920 if (D->isBitField()) 1921 TRY_TO(TraverseStmt(D->getBitWidth())); 1922 else if (D->hasInClassInitializer()) 1923 TRY_TO(TraverseStmt(D->getInClassInitializer())); 1924}) 1925 1926DEF_TRAVERSE_DECL(ObjCAtDefsFieldDecl, { 1927 TRY_TO(TraverseDeclaratorHelper(D)); 1928 if (D->isBitField()) 1929 TRY_TO(TraverseStmt(D->getBitWidth())); 1930 // FIXME: implement the rest. 1931}) 1932 1933DEF_TRAVERSE_DECL(ObjCIvarDecl, { 1934 TRY_TO(TraverseDeclaratorHelper(D)); 1935 if (D->isBitField()) 1936 TRY_TO(TraverseStmt(D->getBitWidth())); 1937 // FIXME: implement the rest. 1938}) 1939 1940template <typename Derived> 1941bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) { 1942 TRY_TO(TraverseDeclTemplateParameterLists(D)); 1943 TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc())); 1944 TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo())); 1945 1946 // If we're an explicit template specialization, iterate over the 1947 // template args that were explicitly specified. If we were doing 1948 // this in typing order, we'd do it between the return type and 1949 // the function args, but both are handled by the FunctionTypeLoc 1950 // above, so we have to choose one side. I've decided to do before. 1951 if (const FunctionTemplateSpecializationInfo *FTSI = 1952 D->getTemplateSpecializationInfo()) { 1953 if (FTSI->getTemplateSpecializationKind() != TSK_Undeclared && 1954 FTSI->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) { 1955 // A specialization might not have explicit template arguments if it has 1956 // a templated return type and concrete arguments. 1957 if (const ASTTemplateArgumentListInfo *TALI = 1958 FTSI->TemplateArgumentsAsWritten) { 1959 TRY_TO(TraverseTemplateArgumentLocsHelper(TALI->getTemplateArgs(), 1960 TALI->NumTemplateArgs)); 1961 } 1962 } 1963 } 1964 1965 // Visit the function type itself, which can be either 1966 // FunctionNoProtoType or FunctionProtoType, or a typedef. This 1967 // also covers the return type and the function parameters, 1968 // including exception specifications. 1969 if (TypeSourceInfo *TSI = D->getTypeSourceInfo()) { 1970 TRY_TO(TraverseTypeLoc(TSI->getTypeLoc())); 1971 } else if (getDerived().shouldVisitImplicitCode()) { 1972 // Visit parameter variable declarations of the implicit function 1973 // if the traverser is visiting implicit code. Parameter variable 1974 // declarations do not have valid TypeSourceInfo, so to visit them 1975 // we need to traverse the declarations explicitly. 1976 for (ParmVarDecl *Parameter : D->parameters()) { 1977 TRY_TO(TraverseDecl(Parameter)); 1978 } 1979 } 1980 1981 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(D)) { 1982 // Constructor initializers. 1983 for (auto *I : Ctor->inits()) { 1984 TRY_TO(TraverseConstructorInitializer(I)); 1985 } 1986 } 1987 1988 if (D->isThisDeclarationADefinition()) { 1989 TRY_TO(TraverseStmt(D->getBody())); // Function body. 1990 } 1991 return true; 1992} 1993 1994DEF_TRAVERSE_DECL(FunctionDecl, { 1995 // We skip decls_begin/decls_end, which are already covered by 1996 // TraverseFunctionHelper(). 1997 ShouldVisitChildren = false; 1998 ReturnValue = TraverseFunctionHelper(D); 1999}) 2000 2001DEF_TRAVERSE_DECL(CXXDeductionGuideDecl, { 2002 // We skip decls_begin/decls_end, which are already covered by 2003 // TraverseFunctionHelper(). 2004 ShouldVisitChildren = false; 2005 ReturnValue = TraverseFunctionHelper(D); 2006}) 2007 2008DEF_TRAVERSE_DECL(CXXMethodDecl, { 2009 // We skip decls_begin/decls_end, which are already covered by 2010 // TraverseFunctionHelper(). 2011 ShouldVisitChildren = false; 2012 ReturnValue = TraverseFunctionHelper(D); 2013}) 2014 2015DEF_TRAVERSE_DECL(CXXConstructorDecl, { 2016 // We skip decls_begin/decls_end, which are already covered by 2017 // TraverseFunctionHelper(). 2018 ShouldVisitChildren = false; 2019 ReturnValue = TraverseFunctionHelper(D); 2020}) 2021 2022// CXXConversionDecl is the declaration of a type conversion operator. 2023// It's not a cast expression. 2024DEF_TRAVERSE_DECL(CXXConversionDecl, { 2025 // We skip decls_begin/decls_end, which are already covered by 2026 // TraverseFunctionHelper(). 2027 ShouldVisitChildren = false; 2028 ReturnValue = TraverseFunctionHelper(D); 2029}) 2030 2031DEF_TRAVERSE_DECL(CXXDestructorDecl, { 2032 // We skip decls_begin/decls_end, which are already covered by 2033 // TraverseFunctionHelper(). 2034 ShouldVisitChildren = false; 2035 ReturnValue = TraverseFunctionHelper(D); 2036}) 2037 2038template <typename Derived> 2039bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) { 2040 TRY_TO(TraverseDeclaratorHelper(D)); 2041 // Default params are taken care of when we traverse the ParmVarDecl. 2042 if (!isa<ParmVarDecl>(D) && 2043 (!D->isCXXForRangeDecl() || getDerived().shouldVisitImplicitCode())) 2044 TRY_TO(TraverseStmt(D->getInit())); 2045 return true; 2046} 2047 2048DEF_TRAVERSE_DECL(VarDecl, { TRY_TO(TraverseVarHelper(D)); }) 2049 2050DEF_TRAVERSE_DECL(ImplicitParamDecl, { TRY_TO(TraverseVarHelper(D)); }) 2051 2052DEF_TRAVERSE_DECL(NonTypeTemplateParmDecl, { 2053 // A non-type template parameter, e.g. "S" in template<int S> class Foo ... 2054 TRY_TO(TraverseDeclaratorHelper(D)); 2055 if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) 2056 TRY_TO(TraverseStmt(D->getDefaultArgument())); 2057}) 2058 2059DEF_TRAVERSE_DECL(ParmVarDecl, { 2060 TRY_TO(TraverseVarHelper(D)); 2061 2062 if (D->hasDefaultArg() && D->hasUninstantiatedDefaultArg() && 2063 !D->hasUnparsedDefaultArg()) 2064 TRY_TO(TraverseStmt(D->getUninstantiatedDefaultArg())); 2065 2066 if (D->hasDefaultArg() && !D->hasUninstantiatedDefaultArg() && 2067 !D->hasUnparsedDefaultArg()) 2068 TRY_TO(TraverseStmt(D->getDefaultArg())); 2069}) 2070 2071#undef DEF_TRAVERSE_DECL 2072 2073// ----------------- Stmt traversal ----------------- 2074// 2075// For stmts, we automate (in the DEF_TRAVERSE_STMT macro) iterating 2076// over the children defined in children() (every stmt defines these, 2077// though sometimes the range is empty). Each individual Traverse* 2078// method only needs to worry about children other than those. To see 2079// what children() does for a given class, see, e.g., 2080// http://clang.llvm.org/doxygen/Stmt_8cpp_source.html 2081 2082// This macro makes available a variable S, the passed-in stmt. 2083#define DEF_TRAVERSE_STMT(STMT, CODE) \ 2084 template <typename Derived> \ 2085 bool RecursiveASTVisitor<Derived>::Traverse##STMT( \ 2086 STMT *S, DataRecursionQueue *Queue) { \ 2087 bool ShouldVisitChildren = true; \ 2088 bool ReturnValue = true; \ 2089 if (!getDerived().shouldTraversePostOrder()) \ 2090 TRY_TO(WalkUpFrom##STMT(S)); \ 2091 { CODE; } \ 2092 if (ShouldVisitChildren) { \ 2093 for (Stmt * SubStmt : getDerived().getStmtChildren(S)) { \ 2094 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt); \ 2095 } \ 2096 } \ 2097 if (!Queue && ReturnValue && getDerived().shouldTraversePostOrder()) \ 2098 TRY_TO(WalkUpFrom##STMT(S)); \ 2099 return ReturnValue; \ 2100 } 2101 2102DEF_TRAVERSE_STMT(GCCAsmStmt, { 2103 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getAsmString()); 2104 for (unsigned I = 0, E = S->getNumInputs(); I < E; ++I) { 2105 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getInputConstraintLiteral(I)); 2106 } 2107 for (unsigned I = 0, E = S->getNumOutputs(); I < E; ++I) { 2108 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOutputConstraintLiteral(I)); 2109 } 2110 for (unsigned I = 0, E = S->getNumClobbers(); I < E; ++I) { 2111 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getClobberStringLiteral(I)); 2112 } 2113 // children() iterates over inputExpr and outputExpr. 2114}) 2115 2116DEF_TRAVERSE_STMT( 2117 MSAsmStmt, 2118 {// FIXME: MS Asm doesn't currently parse Constraints, Clobbers, etc. Once 2119 // added this needs to be implemented. 2120 }) 2121 2122DEF_TRAVERSE_STMT(CXXCatchStmt, { 2123 TRY_TO(TraverseDecl(S->getExceptionDecl())); 2124 // children() iterates over the handler block. 2125}) 2126 2127DEF_TRAVERSE_STMT(DeclStmt, { 2128 for (auto *I : S->decls()) { 2129 TRY_TO(TraverseDecl(I)); 2130 } 2131 // Suppress the default iteration over children() by 2132 // returning. Here's why: A DeclStmt looks like 'type var [= 2133 // initializer]'. The decls above already traverse over the 2134 // initializers, so we don't have to do it again (which 2135 // children() would do). 2136 ShouldVisitChildren = false; 2137}) 2138 2139// These non-expr stmts (most of them), do not need any action except 2140// iterating over the children. 2141DEF_TRAVERSE_STMT(BreakStmt, {}) 2142DEF_TRAVERSE_STMT(CXXTryStmt, {}) 2143DEF_TRAVERSE_STMT(CaseStmt, {}) 2144DEF_TRAVERSE_STMT(CompoundStmt, {}) 2145DEF_TRAVERSE_STMT(ContinueStmt, {}) 2146DEF_TRAVERSE_STMT(DefaultStmt, {}) 2147DEF_TRAVERSE_STMT(DoStmt, {}) 2148DEF_TRAVERSE_STMT(ForStmt, {}) 2149DEF_TRAVERSE_STMT(GotoStmt, {}) 2150DEF_TRAVERSE_STMT(IfStmt, {}) 2151DEF_TRAVERSE_STMT(IndirectGotoStmt, {}) 2152DEF_TRAVERSE_STMT(LabelStmt, {}) 2153DEF_TRAVERSE_STMT(AttributedStmt, {}) 2154DEF_TRAVERSE_STMT(NullStmt, {}) 2155DEF_TRAVERSE_STMT(ObjCAtCatchStmt, {}) 2156DEF_TRAVERSE_STMT(ObjCAtFinallyStmt, {}) 2157DEF_TRAVERSE_STMT(ObjCAtSynchronizedStmt, {}) 2158DEF_TRAVERSE_STMT(ObjCAtThrowStmt, {}) 2159DEF_TRAVERSE_STMT(ObjCAtTryStmt, {}) 2160DEF_TRAVERSE_STMT(ObjCForCollectionStmt, {}) 2161DEF_TRAVERSE_STMT(ObjCAutoreleasePoolStmt, {}) 2162 2163DEF_TRAVERSE_STMT(CXXForRangeStmt, { 2164 if (!getDerived().shouldVisitImplicitCode()) { 2165 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getLoopVarStmt()); 2166 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getRangeInit()); 2167 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody()); 2168 // Visit everything else only if shouldVisitImplicitCode(). 2169 ShouldVisitChildren = false; 2170 } 2171}) 2172 2173DEF_TRAVERSE_STMT(MSDependentExistsStmt, { 2174 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2175 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo())); 2176}) 2177 2178DEF_TRAVERSE_STMT(ReturnStmt, {}) 2179DEF_TRAVERSE_STMT(SwitchStmt, {}) 2180DEF_TRAVERSE_STMT(WhileStmt, {}) 2181 2182DEF_TRAVERSE_STMT(CXXDependentScopeMemberExpr, { 2183 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2184 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo())); 2185 if (S->hasExplicitTemplateArgs()) { 2186 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2187 S->getNumTemplateArgs())); 2188 } 2189}) 2190 2191DEF_TRAVERSE_STMT(DeclRefExpr, { 2192 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2193 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo())); 2194 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2195 S->getNumTemplateArgs())); 2196}) 2197 2198DEF_TRAVERSE_STMT(DependentScopeDeclRefExpr, { 2199 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2200 TRY_TO(TraverseDeclarationNameInfo(S->getNameInfo())); 2201 if (S->hasExplicitTemplateArgs()) { 2202 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2203 S->getNumTemplateArgs())); 2204 } 2205}) 2206 2207DEF_TRAVERSE_STMT(MemberExpr, { 2208 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2209 TRY_TO(TraverseDeclarationNameInfo(S->getMemberNameInfo())); 2210 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2211 S->getNumTemplateArgs())); 2212}) 2213 2214DEF_TRAVERSE_STMT( 2215 ImplicitCastExpr, 2216 {// We don't traverse the cast type, as it's not written in the 2217 // source code. 2218 }) 2219 2220DEF_TRAVERSE_STMT(CStyleCastExpr, { 2221 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2222}) 2223 2224DEF_TRAVERSE_STMT(CXXFunctionalCastExpr, { 2225 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2226}) 2227 2228DEF_TRAVERSE_STMT(CXXConstCastExpr, { 2229 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2230}) 2231 2232DEF_TRAVERSE_STMT(CXXDynamicCastExpr, { 2233 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2234}) 2235 2236DEF_TRAVERSE_STMT(CXXReinterpretCastExpr, { 2237 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2238}) 2239 2240DEF_TRAVERSE_STMT(CXXStaticCastExpr, { 2241 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2242}) 2243 2244template <typename Derived> 2245bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr( 2246 InitListExpr *S, DataRecursionQueue *Queue) { 2247 if (S) { 2248 // Skip this if we traverse postorder. We will visit it later 2249 // in PostVisitStmt. 2250 if (!getDerived().shouldTraversePostOrder()) 2251 TRY_TO(WalkUpFromInitListExpr(S)); 2252 2253 // All we need are the default actions. FIXME: use a helper function. 2254 for (Stmt *SubStmt : S->children()) { 2255 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(SubStmt); 2256 } 2257 } 2258 return true; 2259} 2260 2261// This method is called once for each pair of syntactic and semantic 2262// InitListExpr, and it traverses the subtrees defined by the two forms. This 2263// may cause some of the children to be visited twice, if they appear both in 2264// the syntactic and the semantic form. 2265// 2266// There is no guarantee about which form \p S takes when this method is called. 2267template <typename Derived> 2268bool RecursiveASTVisitor<Derived>::TraverseInitListExpr( 2269 InitListExpr *S, DataRecursionQueue *Queue) { 2270 TRY_TO(TraverseSynOrSemInitListExpr( 2271 S->isSemanticForm() ? S->getSyntacticForm() : S, Queue)); 2272 TRY_TO(TraverseSynOrSemInitListExpr( 2273 S->isSemanticForm() ? S : S->getSemanticForm(), Queue)); 2274 return true; 2275} 2276 2277// GenericSelectionExpr is a special case because the types and expressions 2278// are interleaved. We also need to watch out for null types (default 2279// generic associations). 2280DEF_TRAVERSE_STMT(GenericSelectionExpr, { 2281 TRY_TO(TraverseStmt(S->getControllingExpr())); 2282 for (unsigned i = 0; i != S->getNumAssocs(); ++i) { 2283 if (TypeSourceInfo *TS = S->getAssocTypeSourceInfo(i)) 2284 TRY_TO(TraverseTypeLoc(TS->getTypeLoc())); 2285 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getAssocExpr(i)); 2286 } 2287 ShouldVisitChildren = false; 2288}) 2289 2290// PseudoObjectExpr is a special case because of the weirdness with 2291// syntactic expressions and opaque values. 2292DEF_TRAVERSE_STMT(PseudoObjectExpr, { 2293 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getSyntacticForm()); 2294 for (PseudoObjectExpr::semantics_iterator i = S->semantics_begin(), 2295 e = S->semantics_end(); 2296 i != e; ++i) { 2297 Expr *sub = *i; 2298 if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(sub)) 2299 sub = OVE->getSourceExpr(); 2300 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(sub); 2301 } 2302 ShouldVisitChildren = false; 2303}) 2304 2305DEF_TRAVERSE_STMT(CXXScalarValueInitExpr, { 2306 // This is called for code like 'return T()' where T is a built-in 2307 // (i.e. non-class) type. 2308 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); 2309}) 2310 2311DEF_TRAVERSE_STMT(CXXNewExpr, { 2312 // The child-iterator will pick up the other arguments. 2313 TRY_TO(TraverseTypeLoc(S->getAllocatedTypeSourceInfo()->getTypeLoc())); 2314}) 2315 2316DEF_TRAVERSE_STMT(OffsetOfExpr, { 2317 // The child-iterator will pick up the expression representing 2318 // the field. 2319 // FIMXE: for code like offsetof(Foo, a.b.c), should we get 2320 // making a MemberExpr callbacks for Foo.a, Foo.a.b, and Foo.a.b.c? 2321 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); 2322}) 2323 2324DEF_TRAVERSE_STMT(UnaryExprOrTypeTraitExpr, { 2325 // The child-iterator will pick up the arg if it's an expression, 2326 // but not if it's a type. 2327 if (S->isArgumentType()) 2328 TRY_TO(TraverseTypeLoc(S->getArgumentTypeInfo()->getTypeLoc())); 2329}) 2330 2331DEF_TRAVERSE_STMT(CXXTypeidExpr, { 2332 // The child-iterator will pick up the arg if it's an expression, 2333 // but not if it's a type. 2334 if (S->isTypeOperand()) 2335 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())); 2336}) 2337 2338DEF_TRAVERSE_STMT(MSPropertyRefExpr, { 2339 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2340}) 2341 2342DEF_TRAVERSE_STMT(MSPropertySubscriptExpr, {}) 2343 2344DEF_TRAVERSE_STMT(CXXUuidofExpr, { 2345 // The child-iterator will pick up the arg if it's an expression, 2346 // but not if it's a type. 2347 if (S->isTypeOperand()) 2348 TRY_TO(TraverseTypeLoc(S->getTypeOperandSourceInfo()->getTypeLoc())); 2349}) 2350 2351DEF_TRAVERSE_STMT(TypeTraitExpr, { 2352 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I) 2353 TRY_TO(TraverseTypeLoc(S->getArg(I)->getTypeLoc())); 2354}) 2355 2356DEF_TRAVERSE_STMT(ArrayTypeTraitExpr, { 2357 TRY_TO(TraverseTypeLoc(S->getQueriedTypeSourceInfo()->getTypeLoc())); 2358}) 2359 2360DEF_TRAVERSE_STMT(ExpressionTraitExpr, 2361 { TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getQueriedExpression()); }) 2362 2363DEF_TRAVERSE_STMT(VAArgExpr, { 2364 // The child-iterator will pick up the expression argument. 2365 TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc())); 2366}) 2367 2368DEF_TRAVERSE_STMT(CXXTemporaryObjectExpr, { 2369 // This is called for code like 'return T()' where T is a class type. 2370 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); 2371}) 2372 2373// Walk only the visible parts of lambda expressions. 2374DEF_TRAVERSE_STMT(LambdaExpr, { 2375 for (unsigned I = 0, N = S->capture_size(); I != N; ++I) { 2376 const LambdaCapture *C = S->capture_begin() + I; 2377 if (C->isExplicit() || getDerived().shouldVisitImplicitCode()) { 2378 TRY_TO(TraverseLambdaCapture(S, C, S->capture_init_begin()[I])); 2379 } 2380 } 2381 2382 TypeLoc TL = S->getCallOperator()->getTypeSourceInfo()->getTypeLoc(); 2383 FunctionProtoTypeLoc Proto = TL.getAsAdjusted<FunctionProtoTypeLoc>(); 2384 2385 if (S->hasExplicitParameters() && S->hasExplicitResultType()) { 2386 // Visit the whole type. 2387 TRY_TO(TraverseTypeLoc(TL)); 2388 } else { 2389 if (S->hasExplicitParameters()) { 2390 // Visit parameters. 2391 for (unsigned I = 0, N = Proto.getNumParams(); I != N; ++I) { 2392 TRY_TO(TraverseDecl(Proto.getParam(I))); 2393 } 2394 } else if (S->hasExplicitResultType()) { 2395 TRY_TO(TraverseTypeLoc(Proto.getReturnLoc())); 2396 } 2397 2398 auto *T = Proto.getTypePtr(); 2399 for (const auto &E : T->exceptions()) { 2400 TRY_TO(TraverseType(E)); 2401 } 2402 2403 if (Expr *NE = T->getNoexceptExpr()) 2404 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(NE); 2405 } 2406 2407 ReturnValue = TRAVERSE_STMT_BASE(LambdaBody, LambdaExpr, S, Queue); 2408 ShouldVisitChildren = false; 2409}) 2410 2411DEF_TRAVERSE_STMT(CXXUnresolvedConstructExpr, { 2412 // This is called for code like 'T()', where T is a template argument. 2413 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); 2414}) 2415 2416// These expressions all might take explicit template arguments. 2417// We traverse those if so. FIXME: implement these. 2418DEF_TRAVERSE_STMT(CXXConstructExpr, {}) 2419DEF_TRAVERSE_STMT(CallExpr, {}) 2420DEF_TRAVERSE_STMT(CXXMemberCallExpr, {}) 2421 2422// These exprs (most of them), do not need any action except iterating 2423// over the children. 2424DEF_TRAVERSE_STMT(AddrLabelExpr, {}) 2425DEF_TRAVERSE_STMT(ArraySubscriptExpr, {}) 2426DEF_TRAVERSE_STMT(OMPArraySectionExpr, {}) 2427 2428DEF_TRAVERSE_STMT(BlockExpr, { 2429 TRY_TO(TraverseDecl(S->getBlockDecl())); 2430 return true; // no child statements to loop through. 2431}) 2432 2433DEF_TRAVERSE_STMT(ChooseExpr, {}) 2434DEF_TRAVERSE_STMT(CompoundLiteralExpr, { 2435 TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); 2436}) 2437DEF_TRAVERSE_STMT(CXXBindTemporaryExpr, {}) 2438DEF_TRAVERSE_STMT(CXXBoolLiteralExpr, {}) 2439 2440DEF_TRAVERSE_STMT(CXXDefaultArgExpr, { 2441 if (getDerived().shouldVisitImplicitCode()) 2442 TRY_TO(TraverseStmt(S->getExpr())); 2443}) 2444 2445DEF_TRAVERSE_STMT(CXXDefaultInitExpr, {}) 2446DEF_TRAVERSE_STMT(CXXDeleteExpr, {}) 2447DEF_TRAVERSE_STMT(ExprWithCleanups, {}) 2448DEF_TRAVERSE_STMT(CXXInheritedCtorInitExpr, {}) 2449DEF_TRAVERSE_STMT(CXXNullPtrLiteralExpr, {}) 2450DEF_TRAVERSE_STMT(CXXStdInitializerListExpr, {}) 2451 2452DEF_TRAVERSE_STMT(CXXPseudoDestructorExpr, { 2453 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2454 if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo()) 2455 TRY_TO(TraverseTypeLoc(ScopeInfo->getTypeLoc())); 2456 if (TypeSourceInfo *DestroyedTypeInfo = S->getDestroyedTypeInfo()) 2457 TRY_TO(TraverseTypeLoc(DestroyedTypeInfo->getTypeLoc())); 2458}) 2459 2460DEF_TRAVERSE_STMT(CXXThisExpr, {}) 2461DEF_TRAVERSE_STMT(CXXThrowExpr, {}) 2462DEF_TRAVERSE_STMT(UserDefinedLiteral, {}) 2463DEF_TRAVERSE_STMT(DesignatedInitExpr, {}) 2464DEF_TRAVERSE_STMT(DesignatedInitUpdateExpr, {}) 2465DEF_TRAVERSE_STMT(ExtVectorElementExpr, {}) 2466DEF_TRAVERSE_STMT(GNUNullExpr, {}) 2467DEF_TRAVERSE_STMT(ImplicitValueInitExpr, {}) 2468DEF_TRAVERSE_STMT(NoInitExpr, {}) 2469DEF_TRAVERSE_STMT(ArrayInitLoopExpr, { 2470 // FIXME: The source expression of the OVE should be listed as 2471 // a child of the ArrayInitLoopExpr. 2472 if (OpaqueValueExpr *OVE = S->getCommonExpr()) 2473 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(OVE->getSourceExpr()); 2474}) 2475DEF_TRAVERSE_STMT(ArrayInitIndexExpr, {}) 2476DEF_TRAVERSE_STMT(ObjCBoolLiteralExpr, {}) 2477 2478DEF_TRAVERSE_STMT(ObjCEncodeExpr, { 2479 if (TypeSourceInfo *TInfo = S->getEncodedTypeSourceInfo()) 2480 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc())); 2481}) 2482 2483DEF_TRAVERSE_STMT(ObjCIsaExpr, {}) 2484DEF_TRAVERSE_STMT(ObjCIvarRefExpr, {}) 2485 2486DEF_TRAVERSE_STMT(ObjCMessageExpr, { 2487 if (TypeSourceInfo *TInfo = S->getClassReceiverTypeInfo()) 2488 TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc())); 2489}) 2490 2491DEF_TRAVERSE_STMT(ObjCPropertyRefExpr, {}) 2492DEF_TRAVERSE_STMT(ObjCSubscriptRefExpr, {}) 2493DEF_TRAVERSE_STMT(ObjCProtocolExpr, {}) 2494DEF_TRAVERSE_STMT(ObjCSelectorExpr, {}) 2495DEF_TRAVERSE_STMT(ObjCIndirectCopyRestoreExpr, {}) 2496 2497DEF_TRAVERSE_STMT(ObjCBridgedCastExpr, { 2498 TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc())); 2499}) 2500 2501DEF_TRAVERSE_STMT(ObjCAvailabilityCheckExpr, {}) 2502DEF_TRAVERSE_STMT(ParenExpr, {}) 2503DEF_TRAVERSE_STMT(ParenListExpr, {}) 2504DEF_TRAVERSE_STMT(PredefinedExpr, {}) 2505DEF_TRAVERSE_STMT(ShuffleVectorExpr, {}) 2506DEF_TRAVERSE_STMT(ConvertVectorExpr, {}) 2507DEF_TRAVERSE_STMT(StmtExpr, {}) 2508DEF_TRAVERSE_STMT(UnresolvedLookupExpr, { 2509 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2510 if (S->hasExplicitTemplateArgs()) { 2511 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2512 S->getNumTemplateArgs())); 2513 } 2514}) 2515 2516DEF_TRAVERSE_STMT(UnresolvedMemberExpr, { 2517 TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc())); 2518 if (S->hasExplicitTemplateArgs()) { 2519 TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(), 2520 S->getNumTemplateArgs())); 2521 } 2522}) 2523 2524DEF_TRAVERSE_STMT(SEHTryStmt, {}) 2525DEF_TRAVERSE_STMT(SEHExceptStmt, {}) 2526DEF_TRAVERSE_STMT(SEHFinallyStmt, {}) 2527DEF_TRAVERSE_STMT(SEHLeaveStmt, {}) 2528DEF_TRAVERSE_STMT(CapturedStmt, { TRY_TO(TraverseDecl(S->getCapturedDecl())); }) 2529 2530DEF_TRAVERSE_STMT(CXXOperatorCallExpr, {}) 2531DEF_TRAVERSE_STMT(OpaqueValueExpr, {}) 2532DEF_TRAVERSE_STMT(TypoExpr, {}) 2533DEF_TRAVERSE_STMT(CUDAKernelCallExpr, {}) 2534 2535// These operators (all of them) do not need any action except 2536// iterating over the children. 2537DEF_TRAVERSE_STMT(BinaryConditionalOperator, {}) 2538DEF_TRAVERSE_STMT(ConditionalOperator, {}) 2539DEF_TRAVERSE_STMT(UnaryOperator, {}) 2540DEF_TRAVERSE_STMT(BinaryOperator, {}) 2541DEF_TRAVERSE_STMT(CompoundAssignOperator, {}) 2542DEF_TRAVERSE_STMT(CXXNoexceptExpr, {}) 2543DEF_TRAVERSE_STMT(PackExpansionExpr, {}) 2544DEF_TRAVERSE_STMT(SizeOfPackExpr, {}) 2545DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmPackExpr, {}) 2546DEF_TRAVERSE_STMT(SubstNonTypeTemplateParmExpr, {}) 2547DEF_TRAVERSE_STMT(FunctionParmPackExpr, {}) 2548DEF_TRAVERSE_STMT(MaterializeTemporaryExpr, {}) 2549DEF_TRAVERSE_STMT(CXXFoldExpr, {}) 2550DEF_TRAVERSE_STMT(AtomicExpr, {}) 2551 2552// For coroutines expressions, traverse either the operand 2553// as written or the implied calls, depending on what the 2554// derived class requests. 2555DEF_TRAVERSE_STMT(CoroutineBodyStmt, { 2556 if (!getDerived().shouldVisitImplicitCode()) { 2557 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getBody()); 2558 ShouldVisitChildren = false; 2559 } 2560}) 2561DEF_TRAVERSE_STMT(CoreturnStmt, { 2562 if (!getDerived().shouldVisitImplicitCode()) { 2563 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand()); 2564 ShouldVisitChildren = false; 2565 } 2566}) 2567DEF_TRAVERSE_STMT(CoawaitExpr, { 2568 if (!getDerived().shouldVisitImplicitCode()) { 2569 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand()); 2570 ShouldVisitChildren = false; 2571 } 2572}) 2573DEF_TRAVERSE_STMT(DependentCoawaitExpr, { 2574 if (!getDerived().shouldVisitImplicitCode()) { 2575 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand()); 2576 ShouldVisitChildren = false; 2577 } 2578}) 2579DEF_TRAVERSE_STMT(CoyieldExpr, { 2580 if (!getDerived().shouldVisitImplicitCode()) { 2581 TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getOperand()); 2582 ShouldVisitChildren = false; 2583 } 2584}) 2585 2586// These literals (all of them) do not need any action. 2587DEF_TRAVERSE_STMT(IntegerLiteral, {}) 2588DEF_TRAVERSE_STMT(CharacterLiteral, {}) 2589DEF_TRAVERSE_STMT(FloatingLiteral, {}) 2590DEF_TRAVERSE_STMT(ImaginaryLiteral, {}) 2591DEF_TRAVERSE_STMT(StringLiteral, {}) 2592DEF_TRAVERSE_STMT(ObjCStringLiteral, {}) 2593DEF_TRAVERSE_STMT(ObjCBoxedExpr, {}) 2594DEF_TRAVERSE_STMT(ObjCArrayLiteral, {}) 2595DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, {}) 2596 2597// Traverse OpenCL: AsType, Convert. 2598DEF_TRAVERSE_STMT(AsTypeExpr, {}) 2599 2600// OpenMP directives. 2601template <typename Derived> 2602bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective( 2603 OMPExecutableDirective *S) { 2604 for (auto *C : S->clauses()) { 2605 TRY_TO(TraverseOMPClause(C)); 2606 } 2607 return true; 2608} 2609 2610template <typename Derived> 2611bool 2612RecursiveASTVisitor<Derived>::TraverseOMPLoopDirective(OMPLoopDirective *S) { 2613 return TraverseOMPExecutableDirective(S); 2614} 2615 2616DEF_TRAVERSE_STMT(OMPParallelDirective, 2617 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2618 2619DEF_TRAVERSE_STMT(OMPSimdDirective, 2620 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2621 2622DEF_TRAVERSE_STMT(OMPForDirective, 2623 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2624 2625DEF_TRAVERSE_STMT(OMPForSimdDirective, 2626 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2627 2628DEF_TRAVERSE_STMT(OMPSectionsDirective, 2629 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2630 2631DEF_TRAVERSE_STMT(OMPSectionDirective, 2632 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2633 2634DEF_TRAVERSE_STMT(OMPSingleDirective, 2635 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2636 2637DEF_TRAVERSE_STMT(OMPMasterDirective, 2638 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2639 2640DEF_TRAVERSE_STMT(OMPCriticalDirective, { 2641 TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName())); 2642 TRY_TO(TraverseOMPExecutableDirective(S)); 2643}) 2644 2645DEF_TRAVERSE_STMT(OMPParallelForDirective, 2646 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2647 2648DEF_TRAVERSE_STMT(OMPParallelForSimdDirective, 2649 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2650 2651DEF_TRAVERSE_STMT(OMPParallelSectionsDirective, 2652 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2653 2654DEF_TRAVERSE_STMT(OMPTaskDirective, 2655 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2656 2657DEF_TRAVERSE_STMT(OMPTaskyieldDirective, 2658 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2659 2660DEF_TRAVERSE_STMT(OMPBarrierDirective, 2661 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2662 2663DEF_TRAVERSE_STMT(OMPTaskwaitDirective, 2664 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2665 2666DEF_TRAVERSE_STMT(OMPTaskgroupDirective, 2667 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2668 2669DEF_TRAVERSE_STMT(OMPCancellationPointDirective, 2670 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2671 2672DEF_TRAVERSE_STMT(OMPCancelDirective, 2673 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2674 2675DEF_TRAVERSE_STMT(OMPFlushDirective, 2676 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2677 2678DEF_TRAVERSE_STMT(OMPOrderedDirective, 2679 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2680 2681DEF_TRAVERSE_STMT(OMPAtomicDirective, 2682 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2683 2684DEF_TRAVERSE_STMT(OMPTargetDirective, 2685 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2686 2687DEF_TRAVERSE_STMT(OMPTargetDataDirective, 2688 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2689 2690DEF_TRAVERSE_STMT(OMPTargetEnterDataDirective, 2691 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2692 2693DEF_TRAVERSE_STMT(OMPTargetExitDataDirective, 2694 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2695 2696DEF_TRAVERSE_STMT(OMPTargetParallelDirective, 2697 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2698 2699DEF_TRAVERSE_STMT(OMPTargetParallelForDirective, 2700 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2701 2702DEF_TRAVERSE_STMT(OMPTeamsDirective, 2703 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2704 2705DEF_TRAVERSE_STMT(OMPTargetUpdateDirective, 2706 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2707 2708DEF_TRAVERSE_STMT(OMPTaskLoopDirective, 2709 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2710 2711DEF_TRAVERSE_STMT(OMPTaskLoopSimdDirective, 2712 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2713 2714DEF_TRAVERSE_STMT(OMPDistributeDirective, 2715 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2716 2717DEF_TRAVERSE_STMT(OMPDistributeParallelForDirective, 2718 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2719 2720DEF_TRAVERSE_STMT(OMPDistributeParallelForSimdDirective, 2721 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2722 2723DEF_TRAVERSE_STMT(OMPDistributeSimdDirective, 2724 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2725 2726DEF_TRAVERSE_STMT(OMPTargetParallelForSimdDirective, 2727 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2728 2729DEF_TRAVERSE_STMT(OMPTargetSimdDirective, 2730 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2731 2732DEF_TRAVERSE_STMT(OMPTeamsDistributeDirective, 2733 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2734 2735DEF_TRAVERSE_STMT(OMPTeamsDistributeSimdDirective, 2736 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2737 2738DEF_TRAVERSE_STMT(OMPTeamsDistributeParallelForSimdDirective, 2739 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2740 2741DEF_TRAVERSE_STMT(OMPTeamsDistributeParallelForDirective, 2742 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2743 2744DEF_TRAVERSE_STMT(OMPTargetTeamsDirective, 2745 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2746 2747DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeDirective, 2748 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2749 2750DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForDirective, 2751 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2752 2753DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForSimdDirective, 2754 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2755 2756DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective, 2757 { TRY_TO(TraverseOMPExecutableDirective(S)); }) 2758 2759// OpenMP clauses. 2760template <typename Derived> 2761bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) { 2762 if (!C) 2763 return true; 2764 switch (C->getClauseKind()) { 2765#define OPENMP_CLAUSE(Name, Class) \ 2766 case OMPC_##Name: \ 2767 TRY_TO(Visit##Class(static_cast<Class *>(C))); \ 2768 break; 2769#include "clang/Basic/OpenMPKinds.def" 2770 case OMPC_threadprivate: 2771 case OMPC_uniform: 2772 case OMPC_unknown: 2773 break; 2774 } 2775 return true; 2776} 2777 2778template <typename Derived> 2779bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPreInit( 2780 OMPClauseWithPreInit *Node) { 2781 TRY_TO(TraverseStmt(Node->getPreInitStmt())); 2782 return true; 2783} 2784 2785template <typename Derived> 2786bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPostUpdate( 2787 OMPClauseWithPostUpdate *Node) { 2788 TRY_TO(VisitOMPClauseWithPreInit(Node)); 2789 TRY_TO(TraverseStmt(Node->getPostUpdateExpr())); 2790 return true; 2791} 2792 2793template <typename Derived> 2794bool RecursiveASTVisitor<Derived>::VisitOMPIfClause(OMPIfClause *C) { 2795 TRY_TO(VisitOMPClauseWithPreInit(C)); 2796 TRY_TO(TraverseStmt(C->getCondition())); 2797 return true; 2798} 2799 2800template <typename Derived> 2801bool RecursiveASTVisitor<Derived>::VisitOMPFinalClause(OMPFinalClause *C) { 2802 TRY_TO(TraverseStmt(C->getCondition())); 2803 return true; 2804} 2805 2806template <typename Derived> 2807bool 2808RecursiveASTVisitor<Derived>::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) { 2809 TRY_TO(VisitOMPClauseWithPreInit(C)); 2810 TRY_TO(TraverseStmt(C->getNumThreads())); 2811 return true; 2812} 2813 2814template <typename Derived> 2815bool RecursiveASTVisitor<Derived>::VisitOMPSafelenClause(OMPSafelenClause *C) { 2816 TRY_TO(TraverseStmt(C->getSafelen())); 2817 return true; 2818} 2819 2820template <typename Derived> 2821bool RecursiveASTVisitor<Derived>::VisitOMPSimdlenClause(OMPSimdlenClause *C) { 2822 TRY_TO(TraverseStmt(C->getSimdlen())); 2823 return true; 2824} 2825 2826template <typename Derived> 2827bool 2828RecursiveASTVisitor<Derived>::VisitOMPCollapseClause(OMPCollapseClause *C) { 2829 TRY_TO(TraverseStmt(C->getNumForLoops())); 2830 return true; 2831} 2832 2833template <typename Derived> 2834bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *) { 2835 return true; 2836} 2837 2838template <typename Derived> 2839bool RecursiveASTVisitor<Derived>::VisitOMPProcBindClause(OMPProcBindClause *) { 2840 return true; 2841} 2842 2843template <typename Derived> 2844bool 2845RecursiveASTVisitor<Derived>::VisitOMPScheduleClause(OMPScheduleClause *C) { 2846 TRY_TO(VisitOMPClauseWithPreInit(C)); 2847 TRY_TO(TraverseStmt(C->getChunkSize())); 2848 return true; 2849} 2850 2851template <typename Derived> 2852bool RecursiveASTVisitor<Derived>::VisitOMPOrderedClause(OMPOrderedClause *C) { 2853 TRY_TO(TraverseStmt(C->getNumForLoops())); 2854 return true; 2855} 2856 2857template <typename Derived> 2858bool RecursiveASTVisitor<Derived>::VisitOMPNowaitClause(OMPNowaitClause *) { 2859 return true; 2860} 2861 2862template <typename Derived> 2863bool RecursiveASTVisitor<Derived>::VisitOMPUntiedClause(OMPUntiedClause *) { 2864 return true; 2865} 2866 2867template <typename Derived> 2868bool 2869RecursiveASTVisitor<Derived>::VisitOMPMergeableClause(OMPMergeableClause *) { 2870 return true; 2871} 2872 2873template <typename Derived> 2874bool RecursiveASTVisitor<Derived>::VisitOMPReadClause(OMPReadClause *) { 2875 return true; 2876} 2877 2878template <typename Derived> 2879bool RecursiveASTVisitor<Derived>::VisitOMPWriteClause(OMPWriteClause *) { 2880 return true; 2881} 2882 2883template <typename Derived> 2884bool RecursiveASTVisitor<Derived>::VisitOMPUpdateClause(OMPUpdateClause *) { 2885 return true; 2886} 2887 2888template <typename Derived> 2889bool RecursiveASTVisitor<Derived>::VisitOMPCaptureClause(OMPCaptureClause *) { 2890 return true; 2891} 2892 2893template <typename Derived> 2894bool RecursiveASTVisitor<Derived>::VisitOMPSeqCstClause(OMPSeqCstClause *) { 2895 return true; 2896} 2897 2898template <typename Derived> 2899bool RecursiveASTVisitor<Derived>::VisitOMPThreadsClause(OMPThreadsClause *) { 2900 return true; 2901} 2902 2903template <typename Derived> 2904bool RecursiveASTVisitor<Derived>::VisitOMPSIMDClause(OMPSIMDClause *) { 2905 return true; 2906} 2907 2908template <typename Derived> 2909bool RecursiveASTVisitor<Derived>::VisitOMPNogroupClause(OMPNogroupClause *) { 2910 return true; 2911} 2912 2913template <typename Derived> 2914template <typename T> 2915bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) { 2916 for (auto *E : Node->varlists()) { 2917 TRY_TO(TraverseStmt(E)); 2918 } 2919 return true; 2920} 2921 2922template <typename Derived> 2923bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) { 2924 TRY_TO(VisitOMPClauseList(C)); 2925 for (auto *E : C->private_copies()) { 2926 TRY_TO(TraverseStmt(E)); 2927 } 2928 return true; 2929} 2930 2931template <typename Derived> 2932bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause( 2933 OMPFirstprivateClause *C) { 2934 TRY_TO(VisitOMPClauseList(C)); 2935 TRY_TO(VisitOMPClauseWithPreInit(C)); 2936 for (auto *E : C->private_copies()) { 2937 TRY_TO(TraverseStmt(E)); 2938 } 2939 for (auto *E : C->inits()) { 2940 TRY_TO(TraverseStmt(E)); 2941 } 2942 return true; 2943} 2944 2945template <typename Derived> 2946bool RecursiveASTVisitor<Derived>::VisitOMPLastprivateClause( 2947 OMPLastprivateClause *C) { 2948 TRY_TO(VisitOMPClauseList(C)); 2949 TRY_TO(VisitOMPClauseWithPostUpdate(C)); 2950 for (auto *E : C->private_copies()) { 2951 TRY_TO(TraverseStmt(E)); 2952 } 2953 for (auto *E : C->source_exprs()) { 2954 TRY_TO(TraverseStmt(E)); 2955 } 2956 for (auto *E : C->destination_exprs()) { 2957 TRY_TO(TraverseStmt(E)); 2958 } 2959 for (auto *E : C->assignment_ops()) { 2960 TRY_TO(TraverseStmt(E)); 2961 } 2962 return true; 2963} 2964 2965template <typename Derived> 2966bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) { 2967 TRY_TO(VisitOMPClauseList(C)); 2968 return true; 2969} 2970 2971template <typename Derived> 2972bool RecursiveASTVisitor<Derived>::VisitOMPLinearClause(OMPLinearClause *C) { 2973 TRY_TO(TraverseStmt(C->getStep())); 2974 TRY_TO(TraverseStmt(C->getCalcStep())); 2975 TRY_TO(VisitOMPClauseList(C)); 2976 TRY_TO(VisitOMPClauseWithPostUpdate(C)); 2977 for (auto *E : C->privates()) { 2978 TRY_TO(TraverseStmt(E)); 2979 } 2980 for (auto *E : C->inits()) { 2981 TRY_TO(TraverseStmt(E)); 2982 } 2983 for (auto *E : C->updates()) { 2984 TRY_TO(TraverseStmt(E)); 2985 } 2986 for (auto *E : C->finals()) { 2987 TRY_TO(TraverseStmt(E)); 2988 } 2989 return true; 2990} 2991 2992template <typename Derived> 2993bool RecursiveASTVisitor<Derived>::VisitOMPAlignedClause(OMPAlignedClause *C) { 2994 TRY_TO(TraverseStmt(C->getAlignment())); 2995 TRY_TO(VisitOMPClauseList(C)); 2996 return true; 2997} 2998 2999template <typename Derived> 3000bool RecursiveASTVisitor<Derived>::VisitOMPCopyinClause(OMPCopyinClause *C) { 3001 TRY_TO(VisitOMPClauseList(C)); 3002 for (auto *E : C->source_exprs()) { 3003 TRY_TO(TraverseStmt(E)); 3004 } 3005 for (auto *E : C->destination_exprs()) { 3006 TRY_TO(TraverseStmt(E)); 3007 } 3008 for (auto *E : C->assignment_ops()) { 3009 TRY_TO(TraverseStmt(E)); 3010 } 3011 return true; 3012} 3013 3014template <typename Derived> 3015bool RecursiveASTVisitor<Derived>::VisitOMPCopyprivateClause( 3016 OMPCopyprivateClause *C) { 3017 TRY_TO(VisitOMPClauseList(C)); 3018 for (auto *E : C->source_exprs()) { 3019 TRY_TO(TraverseStmt(E)); 3020 } 3021 for (auto *E : C->destination_exprs()) { 3022 TRY_TO(TraverseStmt(E)); 3023 } 3024 for (auto *E : C->assignment_ops()) { 3025 TRY_TO(TraverseStmt(E)); 3026 } 3027 return true; 3028} 3029 3030template <typename Derived> 3031bool 3032RecursiveASTVisitor<Derived>::VisitOMPReductionClause(OMPReductionClause *C) { 3033 TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc())); 3034 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo())); 3035 TRY_TO(VisitOMPClauseList(C)); 3036 TRY_TO(VisitOMPClauseWithPostUpdate(C)); 3037 for (auto *E : C->privates()) { 3038 TRY_TO(TraverseStmt(E)); 3039 } 3040 for (auto *E : C->lhs_exprs()) { 3041 TRY_TO(TraverseStmt(E)); 3042 } 3043 for (auto *E : C->rhs_exprs()) { 3044 TRY_TO(TraverseStmt(E)); 3045 } 3046 for (auto *E : C->reduction_ops()) { 3047 TRY_TO(TraverseStmt(E)); 3048 } 3049 return true; 3050} 3051 3052template <typename Derived> 3053bool RecursiveASTVisitor<Derived>::VisitOMPTaskReductionClause( 3054 OMPTaskReductionClause *C) { 3055 TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc())); 3056 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo())); 3057 TRY_TO(VisitOMPClauseList(C)); 3058 TRY_TO(VisitOMPClauseWithPostUpdate(C)); 3059 for (auto *E : C->privates()) { 3060 TRY_TO(TraverseStmt(E)); 3061 } 3062 for (auto *E : C->lhs_exprs()) { 3063 TRY_TO(TraverseStmt(E)); 3064 } 3065 for (auto *E : C->rhs_exprs()) { 3066 TRY_TO(TraverseStmt(E)); 3067 } 3068 for (auto *E : C->reduction_ops()) { 3069 TRY_TO(TraverseStmt(E)); 3070 } 3071 return true; 3072} 3073 3074template <typename Derived> 3075bool RecursiveASTVisitor<Derived>::VisitOMPInReductionClause( 3076 OMPInReductionClause *C) { 3077 TRY_TO(TraverseNestedNameSpecifierLoc(C->getQualifierLoc())); 3078 TRY_TO(TraverseDeclarationNameInfo(C->getNameInfo())); 3079 TRY_TO(VisitOMPClauseList(C)); 3080 TRY_TO(VisitOMPClauseWithPostUpdate(C)); 3081 for (auto *E : C->privates()) { 3082 TRY_TO(TraverseStmt(E)); 3083 } 3084 for (auto *E : C->lhs_exprs()) { 3085 TRY_TO(TraverseStmt(E)); 3086 } 3087 for (auto *E : C->rhs_exprs()) { 3088 TRY_TO(TraverseStmt(E)); 3089 } 3090 for (auto *E : C->reduction_ops()) { 3091 TRY_TO(TraverseStmt(E)); 3092 } 3093 for (auto *E : C->taskgroup_descriptors()) 3094 TRY_TO(TraverseStmt(E)); 3095 return true; 3096} 3097 3098template <typename Derived> 3099bool RecursiveASTVisitor<Derived>::VisitOMPFlushClause(OMPFlushClause *C) { 3100 TRY_TO(VisitOMPClauseList(C)); 3101 return true; 3102} 3103 3104template <typename Derived> 3105bool RecursiveASTVisitor<Derived>::VisitOMPDependClause(OMPDependClause *C) { 3106 TRY_TO(VisitOMPClauseList(C)); 3107 return true; 3108} 3109 3110template <typename Derived> 3111bool RecursiveASTVisitor<Derived>::VisitOMPDeviceClause(OMPDeviceClause *C) { 3112 TRY_TO(VisitOMPClauseWithPreInit(C)); 3113 TRY_TO(TraverseStmt(C->getDevice())); 3114 return true; 3115} 3116 3117template <typename Derived> 3118bool RecursiveASTVisitor<Derived>::VisitOMPMapClause(OMPMapClause *C) { 3119 TRY_TO(VisitOMPClauseList(C)); 3120 return true; 3121} 3122 3123template <typename Derived> 3124bool RecursiveASTVisitor<Derived>::VisitOMPNumTeamsClause( 3125 OMPNumTeamsClause *C) { 3126 TRY_TO(VisitOMPClauseWithPreInit(C)); 3127 TRY_TO(TraverseStmt(C->getNumTeams())); 3128 return true; 3129} 3130 3131template <typename Derived> 3132bool RecursiveASTVisitor<Derived>::VisitOMPThreadLimitClause( 3133 OMPThreadLimitClause *C) { 3134 TRY_TO(VisitOMPClauseWithPreInit(C)); 3135 TRY_TO(TraverseStmt(C->getThreadLimit())); 3136 return true; 3137} 3138 3139template <typename Derived> 3140bool RecursiveASTVisitor<Derived>::VisitOMPPriorityClause( 3141 OMPPriorityClause *C) { 3142 TRY_TO(TraverseStmt(C->getPriority())); 3143 return true; 3144} 3145 3146template <typename Derived> 3147bool RecursiveASTVisitor<Derived>::VisitOMPGrainsizeClause( 3148 OMPGrainsizeClause *C) { 3149 TRY_TO(TraverseStmt(C->getGrainsize())); 3150 return true; 3151} 3152 3153template <typename Derived> 3154bool RecursiveASTVisitor<Derived>::VisitOMPNumTasksClause( 3155 OMPNumTasksClause *C) { 3156 TRY_TO(TraverseStmt(C->getNumTasks())); 3157 return true; 3158} 3159 3160template <typename Derived> 3161bool RecursiveASTVisitor<Derived>::VisitOMPHintClause(OMPHintClause *C) { 3162 TRY_TO(TraverseStmt(C->getHint())); 3163 return true; 3164} 3165 3166template <typename Derived> 3167bool RecursiveASTVisitor<Derived>::VisitOMPDistScheduleClause( 3168 OMPDistScheduleClause *C) { 3169 TRY_TO(VisitOMPClauseWithPreInit(C)); 3170 TRY_TO(TraverseStmt(C->getChunkSize())); 3171 return true; 3172} 3173 3174template <typename Derived> 3175bool 3176RecursiveASTVisitor<Derived>::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) { 3177 return true; 3178} 3179 3180template <typename Derived> 3181bool RecursiveASTVisitor<Derived>::VisitOMPToClause(OMPToClause *C) { 3182 TRY_TO(VisitOMPClauseList(C)); 3183 return true; 3184} 3185 3186template <typename Derived> 3187bool RecursiveASTVisitor<Derived>::VisitOMPFromClause(OMPFromClause *C) { 3188 TRY_TO(VisitOMPClauseList(C)); 3189 return true; 3190} 3191 3192template <typename Derived> 3193bool RecursiveASTVisitor<Derived>::VisitOMPUseDevicePtrClause( 3194 OMPUseDevicePtrClause *C) { 3195 TRY_TO(VisitOMPClauseList(C)); 3196 return true; 3197} 3198 3199template <typename Derived> 3200bool RecursiveASTVisitor<Derived>::VisitOMPIsDevicePtrClause( 3201 OMPIsDevicePtrClause *C) { 3202 TRY_TO(VisitOMPClauseList(C)); 3203 return true; 3204} 3205 3206// FIXME: look at the following tricky-seeming exprs to see if we 3207// need to recurse on anything. These are ones that have methods 3208// returning decls or qualtypes or nestednamespecifier -- though I'm 3209// not sure if they own them -- or just seemed very complicated, or 3210// had lots of sub-types to explore. 3211// 3212// VisitOverloadExpr and its children: recurse on template args? etc? 3213 3214// FIXME: go through all the stmts and exprs again, and see which of them 3215// create new types, and recurse on the types (TypeLocs?) of those. 3216// Candidates: 3217// 3218// http://clang.llvm.org/doxygen/classclang_1_1CXXTypeidExpr.html 3219// http://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html 3220// http://clang.llvm.org/doxygen/classclang_1_1TypesCompatibleExpr.html 3221// Every class that has getQualifier. 3222 3223#undef DEF_TRAVERSE_STMT 3224#undef TRAVERSE_STMT 3225#undef TRAVERSE_STMT_BASE 3226 3227#undef TRY_TO 3228 3229} // end namespace clang 3230 3231#endif // LLVM_CLANG_AST_RECURSIVEASTVISITOR_H 3232