94a56856d2
The problem is that a partial match of an (explicit or implicit) allOf matcher
binds results, i.e.
recordDecl(decl().bind("x"), hasName("A"))
can very well bind a record that is not named "A". With this fix, the common
cases of stumbling over this bug are fixed by the BoundNodesMap overwriting the
results of a partial match. An error can still be created with a weird
combination of anyOf and allOf (see inactive test). We need to decide whether
this is worth fixing, as the fix will have performance impact.
Review: http://llvm-reviews.chandlerc.com/D124
llvm-svn: 168177
88 lines
2.6 KiB
C++
88 lines
2.6 KiB
C++
//===--- ASTMatchersInternal.cpp - Structural query framework -------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Implements the base layer of the matcher framework.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/ASTMatchers/ASTMatchers.h"
|
|
#include "clang/ASTMatchers/ASTMatchersInternal.h"
|
|
|
|
namespace clang {
|
|
namespace ast_matchers {
|
|
namespace internal {
|
|
|
|
void BoundNodesMap::copyTo(BoundNodesTreeBuilder *Builder) const {
|
|
for (IDToNodeMap::const_iterator It = NodeMap.begin();
|
|
It != NodeMap.end();
|
|
++It) {
|
|
Builder->setBinding(It->first, It->second);
|
|
}
|
|
}
|
|
|
|
void BoundNodesMap::copyTo(BoundNodesMap *Other) const {
|
|
for (IDToNodeMap::const_iterator I = NodeMap.begin(),
|
|
E = NodeMap.end();
|
|
I != E; ++I) {
|
|
Other->NodeMap[I->first] = I->second;
|
|
}
|
|
}
|
|
|
|
BoundNodesTree::BoundNodesTree() {}
|
|
|
|
BoundNodesTree::BoundNodesTree(
|
|
const BoundNodesMap& Bindings,
|
|
const std::vector<BoundNodesTree> RecursiveBindings)
|
|
: Bindings(Bindings),
|
|
RecursiveBindings(RecursiveBindings) {}
|
|
|
|
void BoundNodesTree::copyTo(BoundNodesTreeBuilder* Builder) const {
|
|
Bindings.copyTo(Builder);
|
|
for (std::vector<BoundNodesTree>::const_iterator
|
|
I = RecursiveBindings.begin(),
|
|
E = RecursiveBindings.end();
|
|
I != E; ++I) {
|
|
Builder->addMatch(*I);
|
|
}
|
|
}
|
|
|
|
void BoundNodesTree::visitMatches(Visitor* ResultVisitor) {
|
|
BoundNodesMap AggregatedBindings;
|
|
visitMatchesRecursively(ResultVisitor, AggregatedBindings);
|
|
}
|
|
|
|
void BoundNodesTree::
|
|
visitMatchesRecursively(Visitor* ResultVisitor,
|
|
const BoundNodesMap& AggregatedBindings) {
|
|
BoundNodesMap CombinedBindings(AggregatedBindings);
|
|
Bindings.copyTo(&CombinedBindings);
|
|
if (RecursiveBindings.empty()) {
|
|
ResultVisitor->visitMatch(BoundNodes(CombinedBindings));
|
|
} else {
|
|
for (unsigned I = 0; I < RecursiveBindings.size(); ++I) {
|
|
RecursiveBindings[I].visitMatchesRecursively(ResultVisitor,
|
|
CombinedBindings);
|
|
}
|
|
}
|
|
}
|
|
|
|
BoundNodesTreeBuilder::BoundNodesTreeBuilder() {}
|
|
|
|
void BoundNodesTreeBuilder::addMatch(const BoundNodesTree& Bindings) {
|
|
RecursiveBindings.push_back(Bindings);
|
|
}
|
|
|
|
BoundNodesTree BoundNodesTreeBuilder::build() const {
|
|
return BoundNodesTree(Bindings, RecursiveBindings);
|
|
}
|
|
|
|
} // end namespace internal
|
|
} // end namespace ast_matchers
|
|
} // end namespace clang
|