-//===--- RecursiveASTVisitor.h - Recursive AST Visitor ----------*- C++ -*-===//
+//===--- DataRecursiveASTVisitor.h - Data-Recursive AST Visitor -*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This file defines the RecursiveASTVisitor interface, which recursively
-// traverses the entire AST.
+// This file defines the DataRecursiveASTVisitor interface, which recursively
+// traverses the entire AST, using data recursion for Stmts/Exprs.
//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_LIBCLANG_RECURSIVEASTVISITOR_H
-#define LLVM_CLANG_LIBCLANG_RECURSIVEASTVISITOR_H
+#ifndef LLVM_CLANG_AST_DATARECURSIVEASTVISITOR_H
+#define LLVM_CLANG_AST_DATARECURSIVEASTVISITOR_H
#include "clang/AST/Decl.h"
#include "clang/AST/DeclCXX.h"
OPERATOR(Shl) OPERATOR(Shr) OPERATOR(And) OPERATOR(Or) OPERATOR(Xor)
namespace clang {
-namespace cxindex {
// A helper macro to implement short-circuiting when recursing. It
// invokes CALL_EXPR, which must be a method call, on the derived
-// object (s.t. a user of RecursiveASTVisitor can override the method
+// object (s.t. a user of DataRecursiveASTVisitor can override the method
// in CALL_EXPR).
#define TRY_TO(CALL_EXPR) \
do { if (!getDerived().CALL_EXPR) return false; } while (0)
/// instantiations will be visited at the same time as the pattern
/// from which they were produced.
template<typename Derived>
-class RecursiveASTVisitor {
+class DataRecursiveASTVisitor {
public:
/// \brief Return a reference to the derived class.
Derived &getDerived() { return *static_cast<Derived*>(this); }
QueuesTy Queues;
class NewQueueRAII {
- RecursiveASTVisitor &RAV;
+ DataRecursiveASTVisitor &RAV;
public:
- NewQueueRAII(StmtsTy &queue, RecursiveASTVisitor &RAV) : RAV(RAV) {
+ NewQueueRAII(StmtsTy &queue, DataRecursiveASTVisitor &RAV) : RAV(RAV) {
RAV.Queues.push_back(&queue);
}
~NewQueueRAII() {
class StmtQueueAction {
StmtsTy &CurrQueue;
public:
- explicit StmtQueueAction(RecursiveASTVisitor &RAV)
+ explicit StmtQueueAction(DataRecursiveASTVisitor &RAV)
: CurrQueue(RAV.getCurrentQueue()) { }
void queue(Stmt *S) {
return getDerived().Traverse##NAME(static_cast<CLASS*>(VAR))
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S) {
+bool DataRecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S) {
if (!S)
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseType(QualType T) {
+bool DataRecursiveASTVisitor<Derived>::TraverseType(QualType T) {
if (T.isNull())
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL) {
+bool DataRecursiveASTVisitor<Derived>::TraverseTypeLoc(TypeLoc TL) {
if (TL.isNull())
return true;
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
+bool DataRecursiveASTVisitor<Derived>::TraverseDecl(Decl *D) {
if (!D)
return true;
#undef DISPATCH
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
+bool DataRecursiveASTVisitor<Derived>::TraverseNestedNameSpecifier(
NestedNameSpecifier *NNS) {
if (!NNS)
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
+bool DataRecursiveASTVisitor<Derived>::TraverseNestedNameSpecifierLoc(
NestedNameSpecifierLoc NNS) {
if (!NNS)
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo(
+bool DataRecursiveASTVisitor<Derived>::TraverseDeclarationNameInfo(
DeclarationNameInfo NameInfo) {
switch (NameInfo.getName().getNameKind()) {
case DeclarationName::CXXConstructorName:
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateName(TemplateName Template) {
if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
TRY_TO(TraverseNestedNameSpecifier(DTN->getQualifier()));
else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgument(
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateArgument(
const TemplateArgument &Arg) {
switch (Arg.getKind()) {
case TemplateArgument::Null:
// FIXME: no template name location?
// FIXME: no source locations for a template argument pack?
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateArgumentLoc(
const TemplateArgumentLoc &ArgLoc) {
const TemplateArgument &Arg = ArgLoc.getArgument();
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArguments(
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateArguments(
const TemplateArgument *Args,
unsigned NumArgs) {
for (unsigned I = 0; I != NumArgs; ++I) {
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
+bool DataRecursiveASTVisitor<Derived>::TraverseConstructorInitializer(
CXXCtorInitializer *Init) {
if (TypeSourceInfo *TInfo = Init->getTypeSourceInfo())
TRY_TO(TraverseTypeLoc(TInfo->getTypeLoc()));
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr::Capture C){
+bool DataRecursiveASTVisitor<Derived>::TraverseLambdaCapture(LambdaExpr::Capture C){
return true;
}
// This macro makes available a variable T, the passed-in type.
#define DEF_TRAVERSE_TYPE(TYPE, CODE) \
template<typename Derived> \
- bool RecursiveASTVisitor<Derived>::Traverse##TYPE (TYPE *T) { \
+ bool DataRecursiveASTVisitor<Derived>::Traverse##TYPE (TYPE *T) { \
TRY_TO(WalkUpFrom##TYPE (T)); \
{ CODE; } \
return true; \
// continue to work.
#define DEF_TRAVERSE_TYPELOC(TYPE, CODE) \
template<typename Derived> \
- bool RecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) { \
+ bool DataRecursiveASTVisitor<Derived>::Traverse##TYPE##Loc(TYPE##Loc TL) { \
if (getDerived().shouldWalkTypesOfTypeLocs()) \
TRY_TO(WalkUpFrom##TYPE(const_cast<TYPE*>(TL.getTypePtr()))); \
TRY_TO(WalkUpFrom##TYPE##Loc(TL)); \
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(
+bool DataRecursiveASTVisitor<Derived>::TraverseQualifiedTypeLoc(
QualifiedTypeLoc TL) {
// Move this over to the 'main' typeloc tree. Note that this is a
// move -- we pretend that we were really looking at the unqualified
})
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {
+bool DataRecursiveASTVisitor<Derived>::TraverseArrayTypeLocHelper(ArrayTypeLoc TL) {
// This isn't available for ArrayType, but is for the ArrayTypeLoc.
TRY_TO(TraverseStmt(TL.getSizeExpr()));
return true;
// than those.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
+bool DataRecursiveASTVisitor<Derived>::TraverseDeclContextHelper(DeclContext *DC) {
if (!DC)
return true;
// This macro makes available a variable D, the passed-in decl.
#define DEF_TRAVERSE_DECL(DECL, CODE) \
template<typename Derived> \
-bool RecursiveASTVisitor<Derived>::Traverse##DECL (DECL *D) { \
+bool DataRecursiveASTVisitor<Derived>::Traverse##DECL (DECL *D) { \
TRY_TO(WalkUpFrom##DECL (D)); \
{ CODE; } \
TRY_TO(TraverseDeclContextHelper(dyn_cast<DeclContext>(D))); \
// A helper method for TemplateDecl's children.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateParameterListHelper(
TemplateParameterList *TPL) {
if (TPL) {
for (TemplateParameterList::iterator I = TPL->begin(), E = TPL->end();
// A helper method for traversing the implicit instantiations of a
// class template.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseClassInstantiations(
+bool DataRecursiveASTVisitor<Derived>::TraverseClassInstantiations(
ClassTemplateDecl *D) {
ClassTemplateDecl::spec_iterator end = D->spec_end();
for (ClassTemplateDecl::spec_iterator it = D->spec_begin(); it != end; ++it) {
// A helper method for traversing the implicit instantiations of a
// class template.
template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseVariableInstantiations(
+bool DataRecursiveASTVisitor<Derived>::TraverseVariableInstantiations(
VarTemplateDecl *D) {
VarTemplateDecl::spec_iterator end = D->spec_end();
for (VarTemplateDecl::spec_iterator it = D->spec_begin(); it != end; ++it) {
// A helper method for traversing the instantiations of a
// function while skipping its specializations.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseFunctionInstantiations(
+bool DataRecursiveASTVisitor<Derived>::TraverseFunctionInstantiations(
FunctionTemplateDecl *D) {
FunctionTemplateDecl::spec_iterator end = D->spec_end();
for (FunctionTemplateDecl::spec_iterator it = D->spec_begin(); it != end;
// Helper methods for RecordDecl and its children.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(
+bool DataRecursiveASTVisitor<Derived>::TraverseRecordHelper(
RecordDecl *D) {
// We shouldn't traverse D->getTypeForDecl(); it's a result of
// declaring the type, not something that was written in the source.
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(
+bool DataRecursiveASTVisitor<Derived>::TraverseCXXRecordHelper(
CXXRecordDecl *D) {
if (!TraverseRecordHelper(D))
return false;
})
template <typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
+bool DataRecursiveASTVisitor<Derived>::TraverseTemplateArgumentLocsHelper(
const TemplateArgumentLoc *TAL, unsigned Count) {
for (unsigned I = 0; I < Count; ++I) {
TRY_TO(TraverseTemplateArgumentLoc(TAL[I]));
DEF_TRAVERSE_DECL(IndirectFieldDecl, {})
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
+bool DataRecursiveASTVisitor<Derived>::TraverseDeclaratorHelper(DeclaratorDecl *D) {
TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
if (D->getTypeSourceInfo())
TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
})
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
+bool DataRecursiveASTVisitor<Derived>::TraverseFunctionHelper(FunctionDecl *D) {
TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
TRY_TO(TraverseDeclarationNameInfo(D->getNameInfo()));
})
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
+bool DataRecursiveASTVisitor<Derived>::TraverseVarHelper(VarDecl *D) {
TRY_TO(TraverseDeclaratorHelper(D));
// Default params are taken care of when we traverse the ParmVarDecl.
if (!isa<ParmVarDecl>(D))
// This macro makes available a variable S, the passed-in stmt.
#define DEF_TRAVERSE_STMT(STMT, CODE) \
template<typename Derived> \
-bool RecursiveASTVisitor<Derived>::Traverse##STMT (STMT *S) { \
+bool DataRecursiveASTVisitor<Derived>::Traverse##STMT (STMT *S) { \
TRY_TO(WalkUpFrom##STMT(S)); \
StmtQueueAction StmtQueue(*this); \
{ CODE; } \
// calls WalkUp*() on the semantic form, before our code can convert
// to the syntactic form.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) {
+bool DataRecursiveASTVisitor<Derived>::TraverseInitListExpr(InitListExpr *S) {
if (InitListExpr *Syn = S->getSyntacticForm())
S = Syn;
TRY_TO(WalkUpFromInitListExpr(S));
// are interleaved. We also need to watch out for null types (default
// generic associations).
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::
+bool DataRecursiveASTVisitor<Derived>::
TraverseGenericSelectionExpr(GenericSelectionExpr *S) {
TRY_TO(WalkUpFromGenericSelectionExpr(S));
StmtQueueAction StmtQueue(*this);
// PseudoObjectExpr is a special case because of the wierdness with
// syntactic expressions and opaque values.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::
+bool DataRecursiveASTVisitor<Derived>::
TraversePseudoObjectExpr(PseudoObjectExpr *S) {
TRY_TO(WalkUpFromPseudoObjectExpr(S));
StmtQueueAction StmtQueue(*this);
// Walk only the visible parts of lambda expressions.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseLambdaExpr(LambdaExpr *S) {
+bool DataRecursiveASTVisitor<Derived>::TraverseLambdaExpr(LambdaExpr *S) {
TRY_TO(WalkUpFromLambdaExpr(S));
for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
// OpenMP clauses.
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
+bool DataRecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
if (!C) return true;
switch (C->getClauseKind()) {
#define OPENMP_CLAUSE(Name, Class) \
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *C) {
+bool DataRecursiveASTVisitor<Derived>::VisitOMPDefaultClause(OMPDefaultClause *C) {
return true;
}
template<typename Derived>
template<typename T>
-void RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
+void DataRecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
for (typename T::varlist_iterator I = Node->varlist_begin(),
E = Node->varlist_end();
I != E; ++I)
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
+bool DataRecursiveASTVisitor<Derived>::VisitOMPPrivateClause(OMPPrivateClause *C) {
VisitOMPClauseList(C);
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
+bool DataRecursiveASTVisitor<Derived>::VisitOMPFirstprivateClause(
OMPFirstprivateClause *C) {
VisitOMPClauseList(C);
return true;
}
template<typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
+bool DataRecursiveASTVisitor<Derived>::VisitOMPSharedClause(OMPSharedClause *C) {
VisitOMPClauseList(C);
return true;
}
#undef TRY_TO
-} // end namespace cxindex
} // end namespace clang
#endif // LLVM_CLANG_LIBCLANG_RECURSIVEASTVISITOR_H
projects / clang / commitdiff