ASTMatchFinder.cpp [plain text]
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include <set>
namespace clang {
namespace ast_matchers {
namespace internal {
namespace {
typedef MatchFinder::MatchCallback MatchCallback;
class ParentMapASTVisitor : public RecursiveASTVisitor<ParentMapASTVisitor> {
public:
typedef llvm::DenseMap<const void*, ast_type_traits::DynTypedNode> ParentMap;
static ParentMap *buildMap(TranslationUnitDecl &TU) {
ParentMapASTVisitor Visitor(new ParentMap);
Visitor.TraverseDecl(&TU);
return Visitor.Parents;
}
private:
typedef RecursiveASTVisitor<ParentMapASTVisitor> VisitorBase;
ParentMapASTVisitor(ParentMap *Parents) : Parents(Parents) {}
bool shouldVisitTemplateInstantiations() const { return true; }
bool shouldVisitImplicitCode() const { return true; }
template <typename T>
bool TraverseNode(T *Node, bool (VisitorBase::*traverse)(T*)) {
if (Node == NULL)
return true;
if (ParentStack.size() > 0)
(*Parents)[Node] = ParentStack.back();
ParentStack.push_back(ast_type_traits::DynTypedNode::create(*Node));
bool Result = (this->*traverse)(Node);
ParentStack.pop_back();
return Result;
}
bool TraverseDecl(Decl *DeclNode) {
return TraverseNode(DeclNode, &VisitorBase::TraverseDecl);
}
bool TraverseStmt(Stmt *StmtNode) {
return TraverseNode(StmtNode, &VisitorBase::TraverseStmt);
}
ParentMap *Parents;
llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
friend class RecursiveASTVisitor<ParentMapASTVisitor>;
};
typedef std::pair<uint64_t, const void*> UntypedMatchInput;
struct MemoizedMatchResult {
bool ResultOfMatch;
BoundNodesTree Nodes;
};
class MatchChildASTVisitor
: public RecursiveASTVisitor<MatchChildASTVisitor> {
public:
typedef RecursiveASTVisitor<MatchChildASTVisitor> VisitorBase;
MatchChildASTVisitor(const DynTypedMatcher *Matcher,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder,
int MaxDepth,
ASTMatchFinder::TraversalKind Traversal,
ASTMatchFinder::BindKind Bind)
: Matcher(Matcher),
Finder(Finder),
Builder(Builder),
CurrentDepth(-1),
MaxDepth(MaxDepth),
Traversal(Traversal),
Bind(Bind),
Matches(false) {}
bool findMatch(const ast_type_traits::DynTypedNode &DynNode) {
reset();
if (const Decl *D = DynNode.get<Decl>())
traverse(*D);
else if (const Stmt *S = DynNode.get<Stmt>())
traverse(*S);
return Matches;
}
bool TraverseDecl(Decl *DeclNode) {
return (DeclNode == NULL) || traverse(*DeclNode);
}
bool TraverseStmt(Stmt *StmtNode) {
const Stmt *StmtToTraverse = StmtNode;
if (Traversal ==
ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses) {
const Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode);
if (ExprNode != NULL) {
StmtToTraverse = ExprNode->IgnoreParenImpCasts();
}
}
return (StmtToTraverse == NULL) || traverse(*StmtToTraverse);
}
bool TraverseType(QualType TypeNode) {
return traverse(TypeNode);
}
bool shouldVisitTemplateInstantiations() const { return true; }
bool shouldVisitImplicitCode() const { return true; }
private:
struct ScopedIncrement {
explicit ScopedIncrement(int *Depth) : Depth(Depth) { ++(*Depth); }
~ScopedIncrement() { --(*Depth); }
private:
int *Depth;
};
void reset() {
Matches = false;
CurrentDepth = -1;
}
bool baseTraverse(const Decl &DeclNode) {
return VisitorBase::TraverseDecl(const_cast<Decl*>(&DeclNode));
}
bool baseTraverse(const Stmt &StmtNode) {
return VisitorBase::TraverseStmt(const_cast<Stmt*>(&StmtNode));
}
bool baseTraverse(QualType TypeNode) {
return VisitorBase::TraverseType(TypeNode);
}
template <typename T>
bool traverse(const T &Node) {
TOOLING_COMPILE_ASSERT(IsBaseType<T>::value,
traverse_can_only_be_instantiated_with_base_type);
ScopedIncrement ScopedDepth(&CurrentDepth);
if (CurrentDepth == 0) {
return baseTraverse(Node);
}
if (Bind != ASTMatchFinder::BK_All) {
if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node),
Finder, Builder)) {
Matches = true;
return false; }
if (CurrentDepth < MaxDepth) {
return baseTraverse(Node);
}
return true;
} else {
BoundNodesTreeBuilder RecursiveBuilder;
if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node),
Finder, &RecursiveBuilder)) {
Matches = true;
Builder->addMatch(RecursiveBuilder.build());
}
if (CurrentDepth < MaxDepth) {
baseTraverse(Node);
}
return true;
}
}
const DynTypedMatcher *const Matcher;
ASTMatchFinder *const Finder;
BoundNodesTreeBuilder *const Builder;
int CurrentDepth;
const int MaxDepth;
const ASTMatchFinder::TraversalKind Traversal;
const ASTMatchFinder::BindKind Bind;
bool Matches;
};
class MatchASTVisitor : public RecursiveASTVisitor<MatchASTVisitor>,
public ASTMatchFinder {
public:
MatchASTVisitor(std::vector<std::pair<const internal::DynTypedMatcher*,
MatchCallback*> > *MatcherCallbackPairs)
: MatcherCallbackPairs(MatcherCallbackPairs),
ActiveASTContext(NULL) {
}
void set_active_ast_context(ASTContext *NewActiveASTContext) {
ActiveASTContext = NewActiveASTContext;
}
bool VisitTypedefDecl(TypedefDecl *DeclNode) {
const Type *TypeNode = DeclNode->getUnderlyingType().getTypePtr();
const Type *CanonicalType = ActiveASTContext->getCanonicalType(TypeNode);
TypeAliases[CanonicalType].insert(DeclNode);
return true;
}
bool TraverseDecl(Decl *DeclNode);
bool TraverseStmt(Stmt *StmtNode);
bool TraverseType(QualType TypeNode);
bool TraverseTypeLoc(TypeLoc TypeNode);
bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
bool memoizedMatchesRecursively(const ast_type_traits::DynTypedNode &Node,
const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, int MaxDepth,
TraversalKind Traversal, BindKind Bind) {
const UntypedMatchInput input(Matcher.getID(), Node.getMemoizationData());
assert(input.second &&
"Fix getMemoizationData once more types allow recursive matching.");
std::pair<MemoizationMap::iterator, bool> InsertResult
= ResultCache.insert(std::make_pair(input, MemoizedMatchResult()));
if (InsertResult.second) {
BoundNodesTreeBuilder DescendantBoundNodesBuilder;
InsertResult.first->second.ResultOfMatch =
matchesRecursively(Node, Matcher, &DescendantBoundNodesBuilder,
MaxDepth, Traversal, Bind);
InsertResult.first->second.Nodes =
DescendantBoundNodesBuilder.build();
}
InsertResult.first->second.Nodes.copyTo(Builder);
return InsertResult.first->second.ResultOfMatch;
}
bool matchesRecursively(const ast_type_traits::DynTypedNode &Node,
const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, int MaxDepth,
TraversalKind Traversal, BindKind Bind) {
MatchChildASTVisitor Visitor(
&Matcher, this, Builder, MaxDepth, Traversal, Bind);
return Visitor.findMatch(Node);
}
virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
const Matcher<NamedDecl> &Base,
BoundNodesTreeBuilder *Builder);
virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder,
TraversalKind Traversal,
BindKind Bind) {
return matchesRecursively(Node, Matcher, Builder, 1, Traversal,
Bind);
}
virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder,
BindKind Bind) {
return memoizedMatchesRecursively(Node, Matcher, Builder, INT_MAX,
TK_AsIs, Bind);
}
virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder) {
if (!Parents) {
Parents.reset(ParentMapASTVisitor::buildMap(
*ActiveASTContext->getTranslationUnitDecl()));
}
ast_type_traits::DynTypedNode Ancestor = Node;
while (Ancestor.get<TranslationUnitDecl>() !=
ActiveASTContext->getTranslationUnitDecl()) {
assert(Ancestor.getMemoizationData() &&
"Invariant broken: only nodes that support memoization may be "
"used in the parent map.");
ParentMapASTVisitor::ParentMap::const_iterator I =
Parents->find(Ancestor.getMemoizationData());
if (I == Parents->end()) {
assert(false &&
"Found node that is not in the parent map.");
return false;
}
Ancestor = I->second;
if (Matcher.matches(Ancestor, this, Builder))
return true;
}
return false;
}
bool shouldVisitTemplateInstantiations() const { return true; }
bool shouldVisitImplicitCode() const { return true; }
private:
class MatchVisitor : public BoundNodesTree::Visitor {
public:
MatchVisitor(ASTContext* Context,
MatchFinder::MatchCallback* Callback)
: Context(Context),
Callback(Callback) {}
virtual void visitMatch(const BoundNodes& BoundNodesView) {
Callback->run(MatchFinder::MatchResult(BoundNodesView, Context));
}
private:
ASTContext* Context;
MatchFinder::MatchCallback* Callback;
};
bool typeHasMatchingAlias(const Type *TypeNode,
const Matcher<NamedDecl> Matcher,
BoundNodesTreeBuilder *Builder) {
const Type *const CanonicalType =
ActiveASTContext->getCanonicalType(TypeNode);
const std::set<const TypedefDecl*> &Aliases = TypeAliases[CanonicalType];
for (std::set<const TypedefDecl*>::const_iterator
It = Aliases.begin(), End = Aliases.end();
It != End; ++It) {
if (Matcher.matches(**It, this, Builder))
return true;
}
return false;
}
template <typename T>
void match(const T &node) {
for (std::vector<std::pair<const internal::DynTypedMatcher*,
MatchCallback*> >::const_iterator
I = MatcherCallbackPairs->begin(), E = MatcherCallbackPairs->end();
I != E; ++I) {
BoundNodesTreeBuilder Builder;
if (I->first->matches(ast_type_traits::DynTypedNode::create(node),
this, &Builder)) {
BoundNodesTree BoundNodes = Builder.build();
MatchVisitor Visitor(ActiveASTContext, I->second);
BoundNodes.visitMatches(&Visitor);
}
}
}
std::vector<std::pair<const internal::DynTypedMatcher*,
MatchCallback*> > *const MatcherCallbackPairs;
ASTContext *ActiveASTContext;
llvm::DenseMap<const Type*, std::set<const TypedefDecl*> > TypeAliases;
typedef llvm::DenseMap<UntypedMatchInput, MemoizedMatchResult> MemoizationMap;
MemoizationMap ResultCache;
llvm::OwningPtr<ParentMapASTVisitor::ParentMap> Parents;
};
bool MatchASTVisitor::classIsDerivedFrom(const CXXRecordDecl *Declaration,
const Matcher<NamedDecl> &Base,
BoundNodesTreeBuilder *Builder) {
if (!Declaration->hasDefinition())
return false;
typedef CXXRecordDecl::base_class_const_iterator BaseIterator;
for (BaseIterator It = Declaration->bases_begin(),
End = Declaration->bases_end(); It != End; ++It) {
const Type *TypeNode = It->getType().getTypePtr();
if (typeHasMatchingAlias(TypeNode, Base, Builder))
return true;
if (TypeNode->getAs<DependentNameType>() != NULL ||
TypeNode->getAs<DependentTemplateSpecializationType>() != NULL ||
TypeNode->getAs<TemplateTypeParmType>() != NULL)
continue;
CXXRecordDecl *ClassDecl = NULL;
TemplateSpecializationType const *TemplateType =
TypeNode->getAs<TemplateSpecializationType>();
if (TemplateType != NULL) {
if (TemplateType->getTemplateName().isDependent())
continue;
CXXRecordDecl *SpecializationDecl =
TemplateType->getAsCXXRecordDecl();
if (SpecializationDecl != NULL) {
ClassDecl = SpecializationDecl;
} else {
ClassDecl = llvm::dyn_cast<CXXRecordDecl>(
TemplateType->getTemplateName()
.getAsTemplateDecl()->getTemplatedDecl());
}
} else {
ClassDecl = TypeNode->getAsCXXRecordDecl();
}
assert(ClassDecl != NULL);
assert(ClassDecl != Declaration);
if (Base.matches(*ClassDecl, this, Builder))
return true;
if (classIsDerivedFrom(ClassDecl, Base, Builder))
return true;
}
return false;
}
bool MatchASTVisitor::TraverseDecl(Decl *DeclNode) {
if (DeclNode == NULL) {
return true;
}
match(*DeclNode);
return RecursiveASTVisitor<MatchASTVisitor>::TraverseDecl(DeclNode);
}
bool MatchASTVisitor::TraverseStmt(Stmt *StmtNode) {
if (StmtNode == NULL) {
return true;
}
match(*StmtNode);
return RecursiveASTVisitor<MatchASTVisitor>::TraverseStmt(StmtNode);
}
bool MatchASTVisitor::TraverseType(QualType TypeNode) {
match(TypeNode);
return RecursiveASTVisitor<MatchASTVisitor>::TraverseType(TypeNode);
}
bool MatchASTVisitor::TraverseTypeLoc(TypeLoc TypeLoc) {
match(TypeLoc.getType());
return RecursiveASTVisitor<MatchASTVisitor>::
TraverseTypeLoc(TypeLoc);
}
bool MatchASTVisitor::TraverseNestedNameSpecifier(NestedNameSpecifier *NNS) {
match(*NNS);
return RecursiveASTVisitor<MatchASTVisitor>::TraverseNestedNameSpecifier(NNS);
}
bool MatchASTVisitor::TraverseNestedNameSpecifierLoc(
NestedNameSpecifierLoc NNS) {
match(NNS);
match(*NNS.getNestedNameSpecifier());
return
RecursiveASTVisitor<MatchASTVisitor>::TraverseNestedNameSpecifierLoc(NNS);
}
class MatchASTConsumer : public ASTConsumer {
public:
MatchASTConsumer(
std::vector<std::pair<const internal::DynTypedMatcher*,
MatchCallback*> > *MatcherCallbackPairs,
MatchFinder::ParsingDoneTestCallback *ParsingDone)
: Visitor(MatcherCallbackPairs),
ParsingDone(ParsingDone) {}
private:
virtual void HandleTranslationUnit(ASTContext &Context) {
if (ParsingDone != NULL) {
ParsingDone->run();
}
Visitor.set_active_ast_context(&Context);
Visitor.TraverseDecl(Context.getTranslationUnitDecl());
Visitor.set_active_ast_context(NULL);
}
MatchASTVisitor Visitor;
MatchFinder::ParsingDoneTestCallback *ParsingDone;
};
} }
MatchFinder::MatchResult::MatchResult(const BoundNodes &Nodes,
ASTContext *Context)
: Nodes(Nodes), Context(Context),
SourceManager(&Context->getSourceManager()) {}
MatchFinder::MatchCallback::~MatchCallback() {}
MatchFinder::ParsingDoneTestCallback::~ParsingDoneTestCallback() {}
MatchFinder::MatchFinder() : ParsingDone(NULL) {}
MatchFinder::~MatchFinder() {
for (std::vector<std::pair<const internal::DynTypedMatcher*,
MatchCallback*> >::const_iterator
It = MatcherCallbackPairs.begin(), End = MatcherCallbackPairs.end();
It != End; ++It) {
delete It->first;
}
}
void MatchFinder::addMatcher(const DeclarationMatcher &NodeMatch,
MatchCallback *Action) {
MatcherCallbackPairs.push_back(std::make_pair(
new internal::Matcher<Decl>(NodeMatch), Action));
}
void MatchFinder::addMatcher(const TypeMatcher &NodeMatch,
MatchCallback *Action) {
MatcherCallbackPairs.push_back(std::make_pair(
new internal::Matcher<QualType>(NodeMatch), Action));
}
void MatchFinder::addMatcher(const StatementMatcher &NodeMatch,
MatchCallback *Action) {
MatcherCallbackPairs.push_back(std::make_pair(
new internal::Matcher<Stmt>(NodeMatch), Action));
}
void MatchFinder::addMatcher(const NestedNameSpecifierMatcher &NodeMatch,
MatchCallback *Action) {
MatcherCallbackPairs.push_back(std::make_pair(
new NestedNameSpecifierMatcher(NodeMatch), Action));
}
void MatchFinder::addMatcher(const NestedNameSpecifierLocMatcher &NodeMatch,
MatchCallback *Action) {
MatcherCallbackPairs.push_back(std::make_pair(
new NestedNameSpecifierLocMatcher(NodeMatch), Action));
}
ASTConsumer *MatchFinder::newASTConsumer() {
return new internal::MatchASTConsumer(&MatcherCallbackPairs, ParsingDone);
}
void MatchFinder::registerTestCallbackAfterParsing(
MatchFinder::ParsingDoneTestCallback *NewParsingDone) {
ParsingDone = NewParsingDone;
}
} }