maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Remove clang::ast_type_traits namespace in favor of clang 

DynTypedNode and ASTNodeKind are implemented as part of the clang AST
library, which uses the main clang namespace. There doesn't seem to be a
need for this extra level of namespacing.

I left behind aliases in the ast_type_traits namespace for out of tree
clients of these APIs. To provide aliases for the enumerators, I used
this pattern:
  namespace ast_type_traits {
  constexpr TraversalKind TK_AsIs = ::clang::TK_AsIs;
  }
I think the typedefs will be useful for migration, but we might be able
to drop these enumerator aliases.

Reviewed By: aaron.ballman

Differential Revision: https://reviews.llvm.org/D74499
This commit is contained in:
Reid Kleckner 2020-02-12 11:34:13 -08:00
parent 2fb6268854
commit cd62511496
29 changed files with 474 additions and 596 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/docs/LibASTMatchersReference.html
View File

@ -7381,11 +7381,11 @@ Usable as: Any Matcher
</pre></td></tr> </pre></td></tr>
<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse1')"><a name="traverse1Anchor">traverse</a></td><td>ast_type_traits::TraversalKind TK, const BindableMatcher&lt;T&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse1')"><a name="traverse1Anchor">traverse</a></td><td>TraversalKind TK, const BindableMatcher&lt;T&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="traverse1"><pre></pre></td></tr> <tr><td colspan="4" class="doc" id="traverse1"><pre></pre></td></tr>
<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse0')"><a name="traverse0Anchor">traverse</a></td><td>ast_type_traits::TraversalKind TK, const Matcher&lt;T&gt; InnerMatcher</td></tr> <tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse0')"><a name="traverse0Anchor">traverse</a></td><td>TraversalKind TK, const Matcher&lt;T&gt; InnerMatcher</td></tr>
<tr><td colspan="4" class="doc" id="traverse0"><pre>Causes all nested matchers to be matched with the specified traversal kind. <tr><td colspan="4" class="doc" id="traverse0"><pre>Causes all nested matchers to be matched with the specified traversal kind.
Given Given
@ -7394,7 +7394,7 @@ Given
int i = 3.0; int i = 3.0;
} }
The matcher The matcher
traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses, traverse(TK_IgnoreImplicitCastsAndParentheses,
varDecl(hasInitializer(floatLiteral().bind("init"))) varDecl(hasInitializer(floatLiteral().bind("init")))
) )
matches the variable declaration with "init" bound to the "3.0". matches the variable declaration with "init" bound to the "3.0".

4
clang/include/clang/AST/ASTContext.h
View File

@ -94,6 +94,7 @@ class CXXMethodDecl;
class CXXRecordDecl; class CXXRecordDecl;
class DiagnosticsEngine; class DiagnosticsEngine;
class ParentMapContext; class ParentMapContext;
class DynTypedNode;
class DynTypedNodeList; class DynTypedNodeList;
class Expr; class Expr;
class FixedPointSemantics; class FixedPointSemantics;
@ -130,9 +131,6 @@ class VarTemplateDecl;
class VTableContextBase; class VTableContextBase;
struct BlockVarCopyInit; struct BlockVarCopyInit;
namespace ast_type_traits {
class DynTypedNode;
}
namespace Builtin { namespace Builtin {

18
clang/include/clang/AST/ASTNodeTraverser.h
View File

@ -66,8 +66,7 @@ class ASTNodeTraverser
/// not already been loaded. /// not already been loaded.
bool Deserialize = false; bool Deserialize = false;
ast_type_traits::TraversalKind Traversal = TraversalKind Traversal = TraversalKind::TK_AsIs;
ast_type_traits::TraversalKind::TK_AsIs;
NodeDelegateType &getNodeDelegate() { NodeDelegateType &getNodeDelegate() {
return getDerived().doGetNodeDelegate(); return getDerived().doGetNodeDelegate();
@ -78,7 +77,7 @@ public:
void setDeserialize(bool D) { Deserialize = D; } void setDeserialize(bool D) { Deserialize = D; }
bool getDeserialize() const { return Deserialize; } bool getDeserialize() const { return Deserialize; }
void SetTraversalKind(ast_type_traits::TraversalKind TK) { Traversal = TK; } void SetTraversalKind(TraversalKind TK) { Traversal = TK; }
void Visit(const Decl *D) { void Visit(const Decl *D) {
getNodeDelegate().AddChild([=] { getNodeDelegate().AddChild([=] {
@ -109,12 +108,12 @@ public:
if (auto *E = dyn_cast_or_null<Expr>(S)) { if (auto *E = dyn_cast_or_null<Expr>(S)) {
switch (Traversal) { switch (Traversal) {
case ast_type_traits::TK_AsIs: case TK_AsIs:
break; break;
case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses: case TK_IgnoreImplicitCastsAndParentheses:
S = E->IgnoreParenImpCasts(); S = E->IgnoreParenImpCasts();
break; break;
case ast_type_traits::TK_IgnoreUnlessSpelledInSource: case TK_IgnoreUnlessSpelledInSource:
S = E->IgnoreUnlessSpelledInSource(); S = E->IgnoreUnlessSpelledInSource();
break; break;
} }
@ -132,8 +131,7 @@ public:
if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S)) if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S))
return; return;
if (isa<LambdaExpr>(S) && if (isa<LambdaExpr>(S) && Traversal == TK_IgnoreUnlessSpelledInSource)
Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource)
return; return;
for (const Stmt *SubStmt : S->children()) for (const Stmt *SubStmt : S->children())
@ -229,7 +227,7 @@ public:
}); });
} }
void Visit(const ast_type_traits::DynTypedNode &N) { void Visit(const DynTypedNode &N) {
// FIXME: Improve this with a switch or a visitor pattern. // FIXME: Improve this with a switch or a visitor pattern.
if (const auto *D = N.get<Decl>()) if (const auto *D = N.get<Decl>())
Visit(D); Visit(D);
@ -659,7 +657,7 @@ public:
} }
void VisitLambdaExpr(const LambdaExpr *Node) { void VisitLambdaExpr(const LambdaExpr *Node) {
if (Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource) { if (Traversal == TK_IgnoreUnlessSpelledInSource) {
for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) { for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
const auto *C = Node->capture_begin() + I; const auto *C = Node->capture_begin() + I;
if (!C->isExplicit()) if (!C->isExplicit())

23
clang/include/clang/AST/ASTTypeTraits.h
View File

@ -33,8 +33,6 @@ namespace clang {
struct PrintingPolicy; struct PrintingPolicy;
namespace ast_type_traits {
/// Defines how we descend a level in the AST when we pass /// Defines how we descend a level in the AST when we pass
/// through expressions. /// through expressions.
enum TraversalKind { enum TraversalKind {
@ -522,18 +520,29 @@ template <typename T, typename EnablerT> struct DynTypedNode::BaseConverter {
} }
}; };
} // end namespace ast_type_traits // Previously these types were defined in the clang::ast_type_traits namespace.
// Provide typedefs so that legacy code can be fixed asynchronously.
namespace ast_type_traits {
using DynTypedNode = ::clang::DynTypedNode;
using ASTNodeKind = ::clang::ASTNodeKind;
using TraversalKind = ::clang::TraversalKind;
constexpr TraversalKind TK_AsIs = ::clang::TK_AsIs;
constexpr TraversalKind TK_IgnoreImplicitCastsAndParentheses =
::clang::TK_IgnoreImplicitCastsAndParentheses;
constexpr TraversalKind TK_IgnoreUnlessSpelledInSource =
::clang::TK_IgnoreUnlessSpelledInSource;
} // namespace ast_type_traits
} // end namespace clang } // end namespace clang
namespace llvm { namespace llvm {
template <> template <>
struct DenseMapInfo<clang::ast_type_traits::ASTNodeKind> struct DenseMapInfo<clang::ASTNodeKind> : clang::ASTNodeKind::DenseMapInfo {};
: clang::ast_type_traits::ASTNodeKind::DenseMapInfo {};
template <> template <>
struct DenseMapInfo<clang::ast_type_traits::DynTypedNode> struct DenseMapInfo<clang::DynTypedNode> : clang::DynTypedNode::DenseMapInfo {};
: clang::ast_type_traits::DynTypedNode::DenseMapInfo {};
} // end namespace llvm } // end namespace llvm

30
clang/include/clang/AST/ParentMapContext.h
View File

@ -52,33 +52,31 @@ public:
/// NestedNameSpecifier or NestedNameSpecifierLoc. /// NestedNameSpecifier or NestedNameSpecifierLoc.
template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node); template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);
DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node); DynTypedNodeList getParents(const DynTypedNode &Node);
/// Clear parent maps. /// Clear parent maps.
void clear(); void clear();
ast_type_traits::TraversalKind getTraversalKind() const { return Traversal; } TraversalKind getTraversalKind() const { return Traversal; }
void setTraversalKind(ast_type_traits::TraversalKind TK) { Traversal = TK; } void setTraversalKind(TraversalKind TK) { Traversal = TK; }
const Expr *traverseIgnored(const Expr *E) const; const Expr *traverseIgnored(const Expr *E) const;
Expr *traverseIgnored(Expr *E) const; Expr *traverseIgnored(Expr *E) const;
ast_type_traits::DynTypedNode DynTypedNode traverseIgnored(const DynTypedNode &N) const;
traverseIgnored(const ast_type_traits::DynTypedNode &N) const;
private: private:
ASTContext &ASTCtx; ASTContext &ASTCtx;
class ParentMap; class ParentMap;
ast_type_traits::TraversalKind Traversal = ast_type_traits::TK_AsIs; TraversalKind Traversal = TK_AsIs;
std::unique_ptr<ParentMap> Parents; std::unique_ptr<ParentMap> Parents;
}; };
class TraversalKindScope { class TraversalKindScope {
ParentMapContext &Ctx; ParentMapContext &Ctx;
ast_type_traits::TraversalKind TK = ast_type_traits::TK_AsIs; TraversalKind TK = TK_AsIs;
public: public:
TraversalKindScope(ASTContext &ASTCtx, TraversalKindScope(ASTContext &ASTCtx, llvm::Optional<TraversalKind> ScopeTK)
llvm::Optional<ast_type_traits::TraversalKind> ScopeTK)
: Ctx(ASTCtx.getParentMapContext()) { : Ctx(ASTCtx.getParentMapContext()) {
TK = Ctx.getTraversalKind(); TK = Ctx.getTraversalKind();
if (ScopeTK) if (ScopeTK)
@ -91,10 +89,9 @@ public:
/// Container for either a single DynTypedNode or for an ArrayRef to /// Container for either a single DynTypedNode or for an ArrayRef to
/// DynTypedNode. For use with ParentMap. /// DynTypedNode. For use with ParentMap.
class DynTypedNodeList { class DynTypedNodeList {
using DynTypedNode = ast_type_traits::DynTypedNode; using DynTypedNode = DynTypedNode;
llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode, llvm::AlignedCharArrayUnion<DynTypedNode, ArrayRef<DynTypedNode>> Storage;
ArrayRef<DynTypedNode>> Storage;
bool IsSingleNode; bool IsSingleNode;
public: public:
@ -106,14 +103,14 @@ public:
new (Storage.buffer) ArrayRef<DynTypedNode>(A); new (Storage.buffer) ArrayRef<DynTypedNode>(A);
} }
const ast_type_traits::DynTypedNode *begin() const { const DynTypedNode *begin() const {
if (!IsSingleNode) if (!IsSingleNode)
return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer) return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
->begin(); ->begin();
return reinterpret_cast<const DynTypedNode *>(Storage.buffer); return reinterpret_cast<const DynTypedNode *>(Storage.buffer);
} }
const ast_type_traits::DynTypedNode *end() const { const DynTypedNode *end() const {
if (!IsSingleNode) if (!IsSingleNode)
return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer) return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
->end(); ->end();
@ -131,7 +128,7 @@ public:
template <typename NodeT> template <typename NodeT>
inline DynTypedNodeList ParentMapContext::getParents(const NodeT &Node) { inline DynTypedNodeList ParentMapContext::getParents(const NodeT &Node) {
return getParents(ast_type_traits::DynTypedNode::create(Node)); return getParents(DynTypedNode::create(Node));
} }
template <typename NodeT> template <typename NodeT>
@ -140,8 +137,7 @@ inline DynTypedNodeList ASTContext::getParents(const NodeT &Node) {
} }
template <> template <>
inline DynTypedNodeList inline DynTypedNodeList ASTContext::getParents(const DynTypedNode &Node) {
ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
return getParentMapContext().getParents(Node); return getParentMapContext().getParents(Node);
} }

20
clang/include/clang/ASTMatchers/ASTMatchFinder.h
View File

@ -182,10 +182,9 @@ public:
/// ///
/// @{ /// @{
template <typename T> void match(const T &Node, ASTContext &Context) { template <typename T> void match(const T &Node, ASTContext &Context) {
match(clang::ast_type_traits::DynTypedNode::create(Node), Context); match(clang::DynTypedNode::create(Node), Context);
} }
void match(const clang::ast_type_traits::DynTypedNode &Node, void match(const clang::DynTypedNode &Node, ASTContext &Context);
ASTContext &Context);
/// @} /// @}
/// Finds all matches in the given AST. /// Finds all matches in the given AST.
@ -242,8 +241,7 @@ SmallVector<BoundNodes, 1>
match(MatcherT Matcher, const NodeT &Node, ASTContext &Context); match(MatcherT Matcher, const NodeT &Node, ASTContext &Context);
template <typename MatcherT> template <typename MatcherT>
SmallVector<BoundNodes, 1> SmallVector<BoundNodes, 1> match(MatcherT Matcher, const DynTypedNode &Node,
match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
ASTContext &Context); ASTContext &Context);
/// @} /// @}
@ -283,8 +281,7 @@ public:
} }
template <typename MatcherT> template <typename MatcherT>
SmallVector<BoundNodes, 1> SmallVector<BoundNodes, 1> match(MatcherT Matcher, const DynTypedNode &Node,
match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
ASTContext &Context) { ASTContext &Context) {
internal::CollectMatchesCallback Callback; internal::CollectMatchesCallback Callback;
MatchFinder Finder; MatchFinder Finder;
@ -296,7 +293,7 @@ match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
template <typename MatcherT, typename NodeT> template <typename MatcherT, typename NodeT>
SmallVector<BoundNodes, 1> SmallVector<BoundNodes, 1>
match(MatcherT Matcher, const NodeT &Node, ASTContext &Context) { match(MatcherT Matcher, const NodeT &Node, ASTContext &Context) {
return match(Matcher, ast_type_traits::DynTypedNode::create(Node), Context); return match(Matcher, DynTypedNode::create(Node), Context);
} }
template <typename MatcherT> template <typename MatcherT>
@ -310,8 +307,8 @@ match(MatcherT Matcher, ASTContext &Context) {
} }
inline SmallVector<BoundNodes, 1> inline SmallVector<BoundNodes, 1>
matchDynamic(internal::DynTypedMatcher Matcher, matchDynamic(internal::DynTypedMatcher Matcher, const DynTypedNode &Node,
const ast_type_traits::DynTypedNode &Node, ASTContext &Context) { ASTContext &Context) {
internal::CollectMatchesCallback Callback; internal::CollectMatchesCallback Callback;
MatchFinder Finder; MatchFinder Finder;
Finder.addDynamicMatcher(Matcher, &Callback); Finder.addDynamicMatcher(Matcher, &Callback);
@ -323,8 +320,7 @@ template <typename NodeT>
SmallVector<BoundNodes, 1> matchDynamic(internal::DynTypedMatcher Matcher, SmallVector<BoundNodes, 1> matchDynamic(internal::DynTypedMatcher Matcher,
const NodeT &Node, const NodeT &Node,
ASTContext &Context) { ASTContext &Context) {
return matchDynamic(Matcher, ast_type_traits::DynTypedNode::create(Node), return matchDynamic(Matcher, DynTypedNode::create(Node), Context);
Context);
} }
inline SmallVector<BoundNodes, 1> inline SmallVector<BoundNodes, 1>

31
clang/include/clang/ASTMatchers/ASTMatchers.h
View File

@ -115,7 +115,7 @@ public:
/// Type of mapping from binding identifiers to bound nodes. This type /// Type of mapping from binding identifiers to bound nodes. This type
/// is an associative container with a key type of \c std::string and a value /// is an associative container with a key type of \c std::string and a value
/// type of \c clang::ast_type_traits::DynTypedNode /// type of \c clang::DynTypedNode
using IDToNodeMap = internal::BoundNodesMap::IDToNodeMap; using IDToNodeMap = internal::BoundNodesMap::IDToNodeMap;
/// Retrieve mapping from binding identifiers to bound nodes. /// Retrieve mapping from binding identifiers to bound nodes.
@ -722,13 +722,13 @@ AST_POLYMORPHIC_MATCHER_P(
/// \endcode /// \endcode
/// The matcher /// The matcher
/// \code /// \code
/// traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses, /// traverse(TK_IgnoreImplicitCastsAndParentheses,
/// varDecl(hasInitializer(floatLiteral().bind("init"))) /// varDecl(hasInitializer(floatLiteral().bind("init")))
/// ) /// )
/// \endcode /// \endcode
/// matches the variable declaration with "init" bound to the "3.0". /// matches the variable declaration with "init" bound to the "3.0".
template <typename T> template <typename T>
internal::Matcher<T> traverse(ast_type_traits::TraversalKind TK, internal::Matcher<T> traverse(TraversalKind TK,
const internal::Matcher<T> &InnerMatcher) { const internal::Matcher<T> &InnerMatcher) {
return internal::DynTypedMatcher::constructRestrictedWrapper( return internal::DynTypedMatcher::constructRestrictedWrapper(
new internal::TraversalMatcher<T>(TK, InnerMatcher), new internal::TraversalMatcher<T>(TK, InnerMatcher),
@ -738,8 +738,7 @@ internal::Matcher<T> traverse(ast_type_traits::TraversalKind TK,
template <typename T> template <typename T>
internal::BindableMatcher<T> internal::BindableMatcher<T>
traverse(ast_type_traits::TraversalKind TK, traverse(TraversalKind TK, const internal::BindableMatcher<T> &InnerMatcher) {
const internal::BindableMatcher<T> &InnerMatcher) {
return internal::BindableMatcher<T>( return internal::BindableMatcher<T>(
internal::DynTypedMatcher::constructRestrictedWrapper( internal::DynTypedMatcher::constructRestrictedWrapper(
new internal::TraversalMatcher<T>(TK, InnerMatcher), new internal::TraversalMatcher<T>(TK, InnerMatcher),
@ -749,7 +748,7 @@ traverse(ast_type_traits::TraversalKind TK,
template <typename... T> template <typename... T>
internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>> internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>
traverse(ast_type_traits::TraversalKind TK, traverse(TraversalKind TK,
const internal::VariadicOperatorMatcher<T...> &InnerMatcher) { const internal::VariadicOperatorMatcher<T...> &InnerMatcher) {
return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>( return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>(
TK, InnerMatcher); TK, InnerMatcher);
@ -759,8 +758,7 @@ template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
typename T, typename ToTypes> typename T, typename ToTypes>
internal::TraversalWrapper< internal::TraversalWrapper<
internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>> internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>>
traverse(ast_type_traits::TraversalKind TK, traverse(TraversalKind TK, const internal::ArgumentAdaptingMatcherFuncAdaptor<
const internal::ArgumentAdaptingMatcherFuncAdaptor<
ArgumentAdapterT, T, ToTypes> &InnerMatcher) { ArgumentAdapterT, T, ToTypes> &InnerMatcher) {
return internal::TraversalWrapper< return internal::TraversalWrapper<
internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T,
@ -771,10 +769,8 @@ template <template <typename T, typename P1> class MatcherT, typename P1,
typename ReturnTypesF> typename ReturnTypesF>
internal::TraversalWrapper< internal::TraversalWrapper<
internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>> internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>
traverse( traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam1<
ast_type_traits::TraversalKind TK, MatcherT, P1, ReturnTypesF> &InnerMatcher) {
const internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>
&InnerMatcher) {
return internal::TraversalWrapper< return internal::TraversalWrapper<
internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>( internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>(
TK, InnerMatcher); TK, InnerMatcher);
@ -784,10 +780,8 @@ template <template <typename T, typename P1, typename P2> class MatcherT,
typename P1, typename P2, typename ReturnTypesF> typename P1, typename P2, typename ReturnTypesF>
internal::TraversalWrapper< internal::TraversalWrapper<
internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>> internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>
traverse( traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam2<
ast_type_traits::TraversalKind TK, MatcherT, P1, P2, ReturnTypesF> &InnerMatcher) {
const internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>
&InnerMatcher) {
return internal::TraversalWrapper< return internal::TraversalWrapper<
internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>( internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>(
TK, InnerMatcher); TK, InnerMatcher);
@ -4584,7 +4578,7 @@ AST_POLYMORPHIC_MATCHER_P(equalsBoundNode,
// they're ever reused. // they're ever reused.
internal::NotEqualsBoundNodePredicate Predicate; internal::NotEqualsBoundNodePredicate Predicate;
Predicate.ID = ID; Predicate.ID = ID;
Predicate.Node = ast_type_traits::DynTypedNode::create(Node); Predicate.Node = DynTypedNode::create(Node);
return Builder->removeBindings(Predicate); return Builder->removeBindings(Predicate);
} }
@ -6735,8 +6729,7 @@ AST_MATCHER_P(Stmt, forFunction, internal::Matcher<FunctionDecl>,
InnerMatcher) { InnerMatcher) {
const auto &Parents = Finder->getASTContext().getParents(Node); const auto &Parents = Finder->getASTContext().getParents(Node);
llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(), llvm::SmallVector<DynTypedNode, 8> Stack(Parents.begin(), Parents.end());
Parents.end());
while(!Stack.empty()) { while(!Stack.empty()) {
const auto &CurNode = Stack.back(); const auto &CurNode = Stack.back();
Stack.pop_back(); Stack.pop_back();

162
clang/include/clang/ASTMatchers/ASTMatchersInternal.h
View File

@ -148,7 +148,7 @@ public:
/// Adds \c Node to the map with key \c ID. /// Adds \c Node to the map with key \c ID.
/// ///
/// The node's base type should be in NodeBaseType or it will be unaccessible. /// The node's base type should be in NodeBaseType or it will be unaccessible.
void addNode(StringRef ID, const ast_type_traits::DynTypedNode& DynNode) { void addNode(StringRef ID, const DynTypedNode &DynNode) {
NodeMap[std::string(ID)] = DynNode; NodeMap[std::string(ID)] = DynNode;
} }
@ -165,10 +165,10 @@ public:
return It->second.get<T>(); return It->second.get<T>();
} }
ast_type_traits::DynTypedNode getNode(StringRef ID) const { DynTypedNode getNode(StringRef ID) const {
IDToNodeMap::const_iterator It = NodeMap.find(ID); IDToNodeMap::const_iterator It = NodeMap.find(ID);
if (It == NodeMap.end()) { if (It == NodeMap.end()) {
return ast_type_traits::DynTypedNode(); return DynTypedNode();
} }
return It->second; return It->second;
} }
@ -183,8 +183,7 @@ public:
/// Note that we're using std::map here, as for memoization: /// Note that we're using std::map here, as for memoization:
/// - we need a comparison operator /// - we need a comparison operator
/// - we need an assignment operator /// - we need an assignment operator
using IDToNodeMap = using IDToNodeMap = std::map<std::string, DynTypedNode, std::less<>>;
std::map<std::string, ast_type_traits::DynTypedNode, std::less<>>;
const IDToNodeMap &getMap() const { const IDToNodeMap &getMap() const {
return NodeMap; return NodeMap;
@ -223,7 +222,7 @@ public:
}; };
/// Add a binding from an id to a node. /// Add a binding from an id to a node.
void setBinding(StringRef Id, const ast_type_traits::DynTypedNode &DynNode) { void setBinding(StringRef Id, const DynTypedNode &DynNode) {
if (Bindings.empty()) if (Bindings.empty())
Bindings.emplace_back(); Bindings.emplace_back();
for (BoundNodesMap &Binding : Bindings) for (BoundNodesMap &Binding : Bindings)
@ -280,11 +279,10 @@ public:
/// ///
/// May bind \p DynNode to an ID via \p Builder, or recurse into /// May bind \p DynNode to an ID via \p Builder, or recurse into
/// the AST via \p Finder. /// the AST via \p Finder.
virtual bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, virtual bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const = 0; BoundNodesTreeBuilder *Builder) const = 0;
virtual llvm::Optional<ast_type_traits::TraversalKind> TraversalKind() const { virtual llvm::Optional<TraversalKind> TraversalKind() const {
return llvm::None; return llvm::None;
} }
}; };
@ -307,8 +305,7 @@ public:
ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const = 0; BoundNodesTreeBuilder *Builder) const = 0;
bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
return matches(DynNode.getUnchecked<T>(), Finder, Builder); return matches(DynNode.getUnchecked<T>(), Finder, Builder);
} }
@ -347,7 +344,7 @@ public:
/// Takes ownership of the provided implementation pointer. /// Takes ownership of the provided implementation pointer.
template <typename T> template <typename T>
DynTypedMatcher(MatcherInterface<T> *Implementation) DynTypedMatcher(MatcherInterface<T> *Implementation)
: SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()), : SupportedKind(ASTNodeKind::getFromNodeKind<T>()),
RestrictKind(SupportedKind), Implementation(Implementation) {} RestrictKind(SupportedKind), Implementation(Implementation) {}
/// Construct from a variadic function. /// Construct from a variadic function.
@ -375,40 +372,38 @@ public:
}; };
static DynTypedMatcher static DynTypedMatcher
constructVariadic(VariadicOperator Op, constructVariadic(VariadicOperator Op, ASTNodeKind SupportedKind,
ast_type_traits::ASTNodeKind SupportedKind,
std::vector<DynTypedMatcher> InnerMatchers); std::vector<DynTypedMatcher> InnerMatchers);
static DynTypedMatcher static DynTypedMatcher
constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher, constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
ast_type_traits::ASTNodeKind RestrictKind); ASTNodeKind RestrictKind);
/// Get a "true" matcher for \p NodeKind. /// Get a "true" matcher for \p NodeKind.
/// ///
/// It only checks that the node is of the right kind. /// It only checks that the node is of the right kind.
static DynTypedMatcher trueMatcher(ast_type_traits::ASTNodeKind NodeKind); static DynTypedMatcher trueMatcher(ASTNodeKind NodeKind);
void setAllowBind(bool AB) { AllowBind = AB; } void setAllowBind(bool AB) { AllowBind = AB; }
/// Check whether this matcher could ever match a node of kind \p Kind. /// Check whether this matcher could ever match a node of kind \p Kind.
/// \return \c false if this matcher will never match such a node. Otherwise, /// \return \c false if this matcher will never match such a node. Otherwise,
/// return \c true. /// return \c true.
bool canMatchNodesOfKind(ast_type_traits::ASTNodeKind Kind) const; bool canMatchNodesOfKind(ASTNodeKind Kind) const;
/// Return a matcher that points to the same implementation, but /// Return a matcher that points to the same implementation, but
/// restricts the node types for \p Kind. /// restricts the node types for \p Kind.
DynTypedMatcher dynCastTo(const ast_type_traits::ASTNodeKind Kind) const; DynTypedMatcher dynCastTo(const ASTNodeKind Kind) const;
/// Returns true if the matcher matches the given \c DynNode. /// Returns true if the matcher matches the given \c DynNode.
bool matches(const ast_type_traits::DynTypedNode &DynNode, bool matches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const; BoundNodesTreeBuilder *Builder) const;
/// Same as matches(), but skips the kind check. /// Same as matches(), but skips the kind check.
/// ///
/// It is faster, but the caller must ensure the node is valid for the /// It is faster, but the caller must ensure the node is valid for the
/// kind of this matcher. /// kind of this matcher.
bool matchesNoKindCheck(const ast_type_traits::DynTypedNode &DynNode, bool matchesNoKindCheck(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const; BoundNodesTreeBuilder *Builder) const;
/// Bind the specified \p ID to the matcher. /// Bind the specified \p ID to the matcher.
@ -423,7 +418,7 @@ public:
/// include both in the ID to make it unique. /// include both in the ID to make it unique.
/// ///
/// \c MatcherIDType supports operator< and provides strict weak ordering. /// \c MatcherIDType supports operator< and provides strict weak ordering.
using MatcherIDType = std::pair<ast_type_traits::ASTNodeKind, uint64_t>; using MatcherIDType = std::pair<ASTNodeKind, uint64_t>;
MatcherIDType getID() const { MatcherIDType getID() const {
/// FIXME: Document the requirements this imposes on matcher /// FIXME: Document the requirements this imposes on matcher
/// implementations (no new() implementation_ during a Matches()). /// implementations (no new() implementation_ during a Matches()).
@ -435,9 +430,7 @@ public:
/// ///
/// \c matches() will always return false unless the node passed is of this /// \c matches() will always return false unless the node passed is of this
/// or a derived type. /// or a derived type.
ast_type_traits::ASTNodeKind getSupportedKind() const { ASTNodeKind getSupportedKind() const { return SupportedKind; }
return SupportedKind;
}
/// Returns \c true if the passed \c DynTypedMatcher can be converted /// Returns \c true if the passed \c DynTypedMatcher can be converted
/// to a \c Matcher<T>. /// to a \c Matcher<T>.
@ -445,9 +438,9 @@ public:
/// This method verifies that the underlying matcher in \c Other can process /// This method verifies that the underlying matcher in \c Other can process
/// nodes of types T. /// nodes of types T.
template <typename T> bool canConvertTo() const { template <typename T> bool canConvertTo() const {
return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); return canConvertTo(ASTNodeKind::getFromNodeKind<T>());
} }
bool canConvertTo(ast_type_traits::ASTNodeKind To) const; bool canConvertTo(ASTNodeKind To) const;
/// Construct a \c Matcher<T> interface around the dynamic matcher. /// Construct a \c Matcher<T> interface around the dynamic matcher.
/// ///
@ -466,20 +459,19 @@ public:
template <typename T> Matcher<T> unconditionalConvertTo() const; template <typename T> Matcher<T> unconditionalConvertTo() const;
private: private:
DynTypedMatcher(ast_type_traits::ASTNodeKind SupportedKind, DynTypedMatcher(ASTNodeKind SupportedKind, ASTNodeKind RestrictKind,
ast_type_traits::ASTNodeKind RestrictKind,
IntrusiveRefCntPtr<DynMatcherInterface> Implementation) IntrusiveRefCntPtr<DynMatcherInterface> Implementation)
: SupportedKind(SupportedKind), RestrictKind(RestrictKind), : SupportedKind(SupportedKind), RestrictKind(RestrictKind),
Implementation(std::move(Implementation)) {} Implementation(std::move(Implementation)) {}
bool AllowBind = false; bool AllowBind = false;
ast_type_traits::ASTNodeKind SupportedKind; ASTNodeKind SupportedKind;
/// A potentially stricter node kind. /// A potentially stricter node kind.
/// ///
/// It allows to perform implicit and dynamic cast of matchers without /// It allows to perform implicit and dynamic cast of matchers without
/// needing to change \c Implementation. /// needing to change \c Implementation.
ast_type_traits::ASTNodeKind RestrictKind; ASTNodeKind RestrictKind;
IntrusiveRefCntPtr<DynMatcherInterface> Implementation; IntrusiveRefCntPtr<DynMatcherInterface> Implementation;
}; };
@ -520,7 +512,7 @@ public:
!std::is_same<From, T>::value> * = nullptr) !std::is_same<From, T>::value> * = nullptr)
: Implementation(restrictMatcher(Other.Implementation)) { : Implementation(restrictMatcher(Other.Implementation)) {
assert(Implementation.getSupportedKind().isSame( assert(Implementation.getSupportedKind().isSame(
ast_type_traits::ASTNodeKind::getFromNodeKind<T>())); ASTNodeKind::getFromNodeKind<T>()));
} }
/// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>. /// Implicitly converts \c Matcher<Type> to \c Matcher<QualType>.
@ -545,8 +537,7 @@ public:
bool matches(const T &Node, bool matches(const T &Node,
ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const { BoundNodesTreeBuilder *Builder) const {
return Implementation.matches(ast_type_traits::DynTypedNode::create(Node), return Implementation.matches(DynTypedNode::create(Node), Finder, Builder);
Finder, Builder);
} }
/// Returns an ID that uniquely identifies the matcher. /// Returns an ID that uniquely identifies the matcher.
@ -576,8 +567,8 @@ public:
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
if (Node.isNull()) if (Node.isNull())
return false; return false;
return this->InnerMatcher.matches( return this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder,
ast_type_traits::DynTypedNode::create(*Node), Finder, Builder); Builder);
} }
}; };
@ -589,13 +580,13 @@ private:
friend class DynTypedMatcher; friend class DynTypedMatcher;
static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) { static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) {
return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); return Other.dynCastTo(ASTNodeKind::getFromNodeKind<T>());
} }
explicit Matcher(const DynTypedMatcher &Implementation) explicit Matcher(const DynTypedMatcher &Implementation)
: Implementation(restrictMatcher(Implementation)) { : Implementation(restrictMatcher(Implementation)) {
assert(this->Implementation.getSupportedKind() assert(this->Implementation.getSupportedKind().isSame(
.isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>())); ASTNodeKind::getFromNodeKind<T>()));
} }
DynTypedMatcher Implementation; DynTypedMatcher Implementation;
@ -615,9 +606,8 @@ inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
template <> template <>
inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const { inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const {
assert(canConvertTo<QualType>()); assert(canConvertTo<QualType>());
const ast_type_traits::ASTNodeKind SourceKind = getSupportedKind(); const ASTNodeKind SourceKind = getSupportedKind();
if (SourceKind.isSame( if (SourceKind.isSame(ASTNodeKind::getFromNodeKind<Type>())) {
ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) {
// We support implicit conversion from Matcher<Type> to Matcher<QualType> // We support implicit conversion from Matcher<Type> to Matcher<QualType>
return unconditionalConvertTo<Type>(); return unconditionalConvertTo<Type>();
} }
@ -919,9 +909,8 @@ private:
/// is \c NULL. /// is \c NULL.
bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder, bool matchesDecl(const Decl *Node, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const { BoundNodesTreeBuilder *Builder) const {
return Node != nullptr && return Node != nullptr && this->InnerMatcher.matches(
this->InnerMatcher.matches( DynTypedNode::create(*Node), Finder, Builder);
ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
} }
}; };
@ -1003,8 +992,8 @@ public:
template <typename T> template <typename T>
bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher, bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder, TraversalKind Traverse,
ast_type_traits::TraversalKind Traverse, BindKind Bind) { BindKind Bind) {
static_assert(std::is_base_of<Decl, T>::value || static_assert(std::is_base_of<Decl, T>::value ||
std::is_base_of<Stmt, T>::value || std::is_base_of<Stmt, T>::value ||
std::is_base_of<NestedNameSpecifier, T>::value || std::is_base_of<NestedNameSpecifier, T>::value ||
@ -1012,8 +1001,8 @@ public:
std::is_base_of<TypeLoc, T>::value || std::is_base_of<TypeLoc, T>::value ||
std::is_base_of<QualType, T>::value, std::is_base_of<QualType, T>::value,
"unsupported type for recursive matching"); "unsupported type for recursive matching");
return matchesChildOf(ast_type_traits::DynTypedNode::create(Node), return matchesChildOf(DynTypedNode::create(Node), getASTContext(), Matcher,
getASTContext(), Matcher, Builder, Traverse, Bind); Builder, Traverse, Bind);
} }
template <typename T> template <typename T>
@ -1028,8 +1017,8 @@ public:
std::is_base_of<TypeLoc, T>::value || std::is_base_of<TypeLoc, T>::value ||
std::is_base_of<QualType, T>::value, std::is_base_of<QualType, T>::value,
"unsupported type for recursive matching"); "unsupported type for recursive matching");
return matchesDescendantOf(ast_type_traits::DynTypedNode::create(Node), return matchesDescendantOf(DynTypedNode::create(Node), getASTContext(),
getASTContext(), Matcher, Builder, Bind); Matcher, Builder, Bind);
} }
// FIXME: Implement support for BindKind. // FIXME: Implement support for BindKind.
@ -1043,27 +1032,24 @@ public:
std::is_base_of<Stmt, T>::value || std::is_base_of<Stmt, T>::value ||
std::is_base_of<TypeLoc, T>::value, std::is_base_of<TypeLoc, T>::value,
"type not allowed for recursive matching"); "type not allowed for recursive matching");
return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node), return matchesAncestorOf(DynTypedNode::create(Node), getASTContext(),
getASTContext(), Matcher, Builder, MatchMode); Matcher, Builder, MatchMode);
} }
virtual ASTContext &getASTContext() const = 0; virtual ASTContext &getASTContext() const = 0;
protected: protected:
virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node, virtual bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx, const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ast_type_traits::TraversalKind Traverse, TraversalKind Traverse, BindKind Bind) = 0;
BindKind Bind) = 0;
virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node, virtual bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx,
const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
BindKind Bind) = 0; BindKind Bind) = 0;
virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node, virtual bool matchesAncestorOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx,
const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
AncestorMatchMode MatchMode) = 0; AncestorMatchMode MatchMode) = 0;
@ -1182,41 +1168,38 @@ struct ArgumentAdaptingMatcherFunc {
template <typename T> template <typename T>
class TraversalMatcher : public WrapperMatcherInterface<T> { class TraversalMatcher : public WrapperMatcherInterface<T> {
ast_type_traits::TraversalKind Traversal; TraversalKind Traversal;
public: public:
explicit TraversalMatcher(ast_type_traits::TraversalKind TK, explicit TraversalMatcher(TraversalKind TK, const Matcher<T> &ChildMatcher)
const Matcher<T> &ChildMatcher)
: TraversalMatcher::WrapperMatcherInterface(ChildMatcher), Traversal(TK) { : TraversalMatcher::WrapperMatcherInterface(ChildMatcher), Traversal(TK) {
} }
bool matches(const T &Node, ASTMatchFinder *Finder, bool matches(const T &Node, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
return this->InnerMatcher.matches( return this->InnerMatcher.matches(DynTypedNode::create(Node), Finder,
ast_type_traits::DynTypedNode::create(Node), Finder, Builder); Builder);
} }
llvm::Optional<ast_type_traits::TraversalKind> llvm::Optional<TraversalKind> TraversalKind() const override {
TraversalKind() const override {
return Traversal; return Traversal;
} }
}; };
template <typename MatcherType> class TraversalWrapper { template <typename MatcherType> class TraversalWrapper {
public: public:
TraversalWrapper(ast_type_traits::TraversalKind TK, TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher)
const MatcherType &InnerMatcher)
: TK(TK), InnerMatcher(InnerMatcher) {} : TK(TK), InnerMatcher(InnerMatcher) {}
template <typename T> operator Matcher<T>() const { template <typename T> operator Matcher<T>() const {
return internal::DynTypedMatcher::constructRestrictedWrapper( return internal::DynTypedMatcher::constructRestrictedWrapper(
new internal::TraversalMatcher<T>(TK, InnerMatcher), new internal::TraversalMatcher<T>(TK, InnerMatcher),
ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) ASTNodeKind::getFromNodeKind<T>())
.template unconditionalConvertTo<T>(); .template unconditionalConvertTo<T>();
} }
private: private:
ast_type_traits::TraversalKind TK; TraversalKind TK;
MatcherType InnerMatcher; MatcherType InnerMatcher;
}; };
@ -1299,8 +1282,7 @@ public:
template <typename T> template <typename T>
operator Matcher<T>() const { operator Matcher<T>() const {
return DynTypedMatcher::trueMatcher( return DynTypedMatcher::trueMatcher(ASTNodeKind::getFromNodeKind<T>())
ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
.template unconditionalConvertTo<T>(); .template unconditionalConvertTo<T>();
} }
}; };
@ -1348,7 +1330,7 @@ public:
bool matches(const T &Node, ASTMatchFinder *Finder, bool matches(const T &Node, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
return Finder->matchesChildOf(Node, this->InnerMatcher, Builder, return Finder->matchesChildOf(Node, this->InnerMatcher, Builder,
ast_type_traits::TraversalKind::TK_AsIs, TraversalKind::TK_AsIs,
ASTMatchFinder::BK_First); ASTMatchFinder::BK_First);
} }
}; };
@ -1371,7 +1353,7 @@ class ForEachMatcher : public WrapperMatcherInterface<T> {
BoundNodesTreeBuilder* Builder) const override { BoundNodesTreeBuilder* Builder) const override {
return Finder->matchesChildOf( return Finder->matchesChildOf(
Node, this->InnerMatcher, Builder, Node, this->InnerMatcher, Builder,
ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses, TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
ASTMatchFinder::BK_All); ASTMatchFinder::BK_All);
} }
}; };
@ -1392,7 +1374,7 @@ public:
template <typename T> operator Matcher<T>() const { template <typename T> operator Matcher<T>() const {
return DynTypedMatcher::constructVariadic( return DynTypedMatcher::constructVariadic(
Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(), Op, ASTNodeKind::getFromNodeKind<T>(),
getMatchers<T>(std::index_sequence_for<Ps...>())) getMatchers<T>(std::index_sequence_for<Ps...>()))
.template unconditionalConvertTo<T>(); .template unconditionalConvertTo<T>();
} }
@ -1448,9 +1430,8 @@ BindableMatcher<T> makeAllOfComposite(
std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()), std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()),
PI(InnerMatchers.end())); PI(InnerMatchers.end()));
return BindableMatcher<T>( return BindableMatcher<T>(
DynTypedMatcher::constructVariadic( DynTypedMatcher::constructVariadic(DynTypedMatcher::VO_AllOf,
DynTypedMatcher::VO_AllOf, ASTNodeKind::getFromNodeKind<T>(),
ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
std::move(DynMatchers)) std::move(DynMatchers))
.template unconditionalConvertTo<T>()); .template unconditionalConvertTo<T>());
} }
@ -1652,9 +1633,8 @@ public:
} }
private: private:
static ast_type_traits::DynTypedNode static DynTypedNode extract(const NestedNameSpecifierLoc &Loc) {
extract(const NestedNameSpecifierLoc &Loc) { return DynTypedNode::create(*Loc.getNestedNameSpecifier());
return ast_type_traits::DynTypedNode::create(*Loc.getNestedNameSpecifier());
} }
}; };
@ -1671,8 +1651,8 @@ public:
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
if (!Node) if (!Node)
return false; return false;
return this->InnerMatcher.matches( return this->InnerMatcher.matches(DynTypedNode::create(Node.getType()),
ast_type_traits::DynTypedNode::create(Node.getType()), Finder, Builder); Finder, Builder);
} }
}; };
@ -1692,8 +1672,8 @@ public:
QualType NextNode = (Node.*TraverseFunction)(); QualType NextNode = (Node.*TraverseFunction)();
if (NextNode.isNull()) if (NextNode.isNull())
return false; return false;
return this->InnerMatcher.matches( return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder,
ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder); Builder);
} }
private: private:
@ -1716,8 +1696,8 @@ public:
TypeLoc NextNode = (Node.*TraverseFunction)(); TypeLoc NextNode = (Node.*TraverseFunction)();
if (!NextNode) if (!NextNode)
return false; return false;
return this->InnerMatcher.matches( return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder,
ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder); Builder);
} }
private: private:
@ -1817,7 +1797,7 @@ struct NotEqualsBoundNodePredicate {
} }
std::string ID; std::string ID;
ast_type_traits::DynTypedNode Node; DynTypedNode Node;
}; };
template <typename Ty> template <typename Ty>

19
clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
View File

@ -43,11 +43,10 @@ class ArgKind {
ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); } ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); }
/// Constructor for matcher types. /// Constructor for matcher types.
ArgKind(ast_type_traits::ASTNodeKind MatcherKind) ArgKind(ASTNodeKind MatcherKind) : K(AK_Matcher), MatcherKind(MatcherKind) {}
: K(AK_Matcher), MatcherKind(MatcherKind) {}
Kind getArgKind() const { return K; } Kind getArgKind() const { return K; }
ast_type_traits::ASTNodeKind getMatcherKind() const { ASTNodeKind getMatcherKind() const {
assert(K == AK_Matcher); assert(K == AK_Matcher);
return MatcherKind; return MatcherKind;
} }
@ -71,7 +70,7 @@ class ArgKind {
private: private:
Kind K; Kind K;
ast_type_traits::ASTNodeKind MatcherKind; ASTNodeKind MatcherKind;
}; };
using ast_matchers::internal::DynTypedMatcher; using ast_matchers::internal::DynTypedMatcher;
@ -93,7 +92,7 @@ class VariantMatcher {
/// Methods that depend on T from hasTypedMatcher/getTypedMatcher. /// Methods that depend on T from hasTypedMatcher/getTypedMatcher.
class MatcherOps { class MatcherOps {
public: public:
MatcherOps(ast_type_traits::ASTNodeKind NodeKind) : NodeKind(NodeKind) {} MatcherOps(ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
bool canConstructFrom(const DynTypedMatcher &Matcher, bool canConstructFrom(const DynTypedMatcher &Matcher,
bool &IsExactMatch) const; bool &IsExactMatch) const;
@ -114,7 +113,7 @@ class VariantMatcher {
~MatcherOps() = default; ~MatcherOps() = default;
private: private:
ast_type_traits::ASTNodeKind NodeKind; ASTNodeKind NodeKind;
}; };
/// Payload interface to be specialized by each matcher type. /// Payload interface to be specialized by each matcher type.
@ -127,7 +126,7 @@ class VariantMatcher {
virtual std::string getTypeAsString() const = 0; virtual std::string getTypeAsString() const = 0;
virtual llvm::Optional<DynTypedMatcher> virtual llvm::Optional<DynTypedMatcher>
getTypedMatcher(const MatcherOps &Ops) const = 0; getTypedMatcher(const MatcherOps &Ops) const = 0;
virtual bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, virtual bool isConvertibleTo(ASTNodeKind Kind,
unsigned *Specificity) const = 0; unsigned *Specificity) const = 0;
}; };
@ -184,8 +183,7 @@ public:
/// ///
/// \param Specificity value corresponding to the "specificity" of the /// \param Specificity value corresponding to the "specificity" of the
/// conversion. /// conversion.
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const {
unsigned *Specificity) const {
if (Value) if (Value)
return Value->isConvertibleTo(Kind, Specificity); return Value->isConvertibleTo(Kind, Specificity);
return false; return false;
@ -223,8 +221,7 @@ private:
template <typename T> template <typename T>
struct VariantMatcher::TypedMatcherOps final : VariantMatcher::MatcherOps { struct VariantMatcher::TypedMatcherOps final : VariantMatcher::MatcherOps {
TypedMatcherOps() TypedMatcherOps() : MatcherOps(ASTNodeKind::getFromNodeKind<T>()) {}
: MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
typedef ast_matchers::internal::Matcher<T> MatcherT; typedef ast_matchers::internal::Matcher<T> MatcherT;
DynTypedMatcher DynTypedMatcher

4
clang/include/clang/Tooling/ASTDiff/ASTDiff.h
View File

@ -37,11 +37,11 @@ enum ChangeKind {
struct Node { struct Node {
NodeId Parent, LeftMostDescendant, RightMostDescendant; NodeId Parent, LeftMostDescendant, RightMostDescendant;
int Depth, Height, Shift = 0; int Depth, Height, Shift = 0;
ast_type_traits::DynTypedNode ASTNode; DynTypedNode ASTNode;
SmallVector<NodeId, 4> Children; SmallVector<NodeId, 4> Children;
ChangeKind Change = None; ChangeKind Change = None;
ast_type_traits::ASTNodeKind getType() const; ASTNodeKind getType() const;
StringRef getTypeLabel() const; StringRef getTypeLabel() const;
bool isLeaf() const { return Children.empty(); } bool isLeaf() const { return Children.empty(); }
llvm::Optional<StringRef> getIdentifier() const; llvm::Optional<StringRef> getIdentifier() const;

2
clang/include/clang/Tooling/ASTDiff/ASTDiffInternal.h
View File

@ -15,7 +15,7 @@
namespace clang { namespace clang {
namespace diff { namespace diff {
using DynTypedNode = ast_type_traits::DynTypedNode; using DynTypedNode = DynTypedNode;
class SyntaxTree; class SyntaxTree;
class SyntaxTreeImpl; class SyntaxTreeImpl;

5
clang/include/clang/Tooling/Refactoring/ASTSelection.h
View File

@ -48,12 +48,11 @@ enum class SourceSelectionKind {
/// actually be selected, e.g. a statement in macro whose child is in a macro /// actually be selected, e.g. a statement in macro whose child is in a macro
/// argument. /// argument.
struct SelectedASTNode { struct SelectedASTNode {
ast_type_traits::DynTypedNode Node; DynTypedNode Node;
SourceSelectionKind SelectionKind; SourceSelectionKind SelectionKind;
std::vector<SelectedASTNode> Children; std::vector<SelectedASTNode> Children;
SelectedASTNode(const ast_type_traits::DynTypedNode &Node, SelectedASTNode(const DynTypedNode &Node, SourceSelectionKind SelectionKind)
SourceSelectionKind SelectionKind)
: Node(Node), SelectionKind(SelectionKind) {} : Node(Node), SelectionKind(SelectionKind) {}
SelectedASTNode(SelectedASTNode &&) = default; SelectedASTNode(SelectedASTNode &&) = default;
SelectedASTNode &operator=(SelectedASTNode &&) = default; SelectedASTNode &operator=(SelectedASTNode &&) = default;

6
clang/lib/AST/ASTTypeTraits.cpp
View File

@ -18,8 +18,7 @@
#include "clang/AST/NestedNameSpecifier.h" #include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/OpenMPClause.h" #include "clang/AST/OpenMPClause.h"
namespace clang { using namespace clang;
namespace ast_type_traits {
const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = { const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
{ NKI_None, "<None>" }, { NKI_None, "<None>" },
@ -178,6 +177,3 @@ SourceRange DynTypedNode::getSourceRange() const {
return SourceRange(C->getBeginLoc(), C->getEndLoc()); return SourceRange(C->getBeginLoc(), C->getEndLoc());
return SourceRange(); return SourceRange();
} }
} // end namespace ast_type_traits
} // end namespace clang

84
clang/lib/AST/ParentMapContext.cpp
View File

@ -34,54 +34,53 @@ Expr *ParentMapContext::traverseIgnored(Expr *E) const {
return nullptr; return nullptr;
switch (Traversal) { switch (Traversal) {
case ast_type_traits::TK_AsIs: case TK_AsIs:
return E; return E;
case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses: case TK_IgnoreImplicitCastsAndParentheses:
return E->IgnoreParenImpCasts(); return E->IgnoreParenImpCasts();
case ast_type_traits::TK_IgnoreUnlessSpelledInSource: case TK_IgnoreUnlessSpelledInSource:
return E->IgnoreUnlessSpelledInSource(); return E->IgnoreUnlessSpelledInSource();
} }
llvm_unreachable("Invalid Traversal type!"); llvm_unreachable("Invalid Traversal type!");
} }
ast_type_traits::DynTypedNode DynTypedNode ParentMapContext::traverseIgnored(const DynTypedNode &N) const {
ParentMapContext::traverseIgnored(const ast_type_traits::DynTypedNode &N) const {
if (const auto *E = N.get<Expr>()) { if (const auto *E = N.get<Expr>()) {
return ast_type_traits::DynTypedNode::create(*traverseIgnored(E)); return DynTypedNode::create(*traverseIgnored(E));
} }
return N; return N;
} }
class ParentMapContext::ParentMap { class ParentMapContext::ParentMap {
/// Contains parents of a node. /// Contains parents of a node.
using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>; using ParentVector = llvm::SmallVector<DynTypedNode, 2>;
/// Maps from a node to its parents. This is used for nodes that have /// Maps from a node to its parents. This is used for nodes that have
/// pointer identity only, which are more common and we can save space by /// pointer identity only, which are more common and we can save space by
/// only storing a unique pointer to them. /// only storing a unique pointer to them.
using ParentMapPointers = llvm::DenseMap< using ParentMapPointers =
const void *, llvm::DenseMap<const void *,
llvm::PointerUnion<const Decl *, const Stmt *, llvm::PointerUnion<const Decl *, const Stmt *,
ast_type_traits::DynTypedNode *, ParentVector *>>; DynTypedNode *, ParentVector *>>;
/// Parent map for nodes without pointer identity. We store a full /// Parent map for nodes without pointer identity. We store a full
/// DynTypedNode for all keys. /// DynTypedNode for all keys.
using ParentMapOtherNodes = llvm::DenseMap< using ParentMapOtherNodes =
ast_type_traits::DynTypedNode, llvm::DenseMap<DynTypedNode,
llvm::PointerUnion<const Decl *, const Stmt *, llvm::PointerUnion<const Decl *, const Stmt *,
ast_type_traits::DynTypedNode *, ParentVector *>>; DynTypedNode *, ParentVector *>>;
ParentMapPointers PointerParents; ParentMapPointers PointerParents;
ParentMapOtherNodes OtherParents; ParentMapOtherNodes OtherParents;
class ASTVisitor; class ASTVisitor;
static ast_type_traits::DynTypedNode static DynTypedNode
getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) { getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
if (const auto *D = U.dyn_cast<const Decl *>()) if (const auto *D = U.dyn_cast<const Decl *>())
return ast_type_traits::DynTypedNode::create(*D); return DynTypedNode::create(*D);
if (const auto *S = U.dyn_cast<const Stmt *>()) if (const auto *S = U.dyn_cast<const Stmt *>())
return ast_type_traits::DynTypedNode::create(*S); return DynTypedNode::create(*S);
return *U.get<ast_type_traits::DynTypedNode *>(); return *U.get<DynTypedNode *>();
} }
template <typename NodeTy, typename MapTy> template <typename NodeTy, typename MapTy>
@ -89,7 +88,7 @@ class ParentMapContext::ParentMap {
const MapTy &Map) { const MapTy &Map) {
auto I = Map.find(Node); auto I = Map.find(Node);
if (I == Map.end()) { if (I == Map.end()) {
return llvm::ArrayRef<ast_type_traits::DynTypedNode>(); return llvm::ArrayRef<DynTypedNode>();
} }
if (const auto *V = I->second.template dyn_cast<ParentVector *>()) { if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
return llvm::makeArrayRef(*V); return llvm::makeArrayRef(*V);
@ -101,28 +100,26 @@ public:
ParentMap(ASTContext &Ctx); ParentMap(ASTContext &Ctx);
~ParentMap() { ~ParentMap() {
for (const auto &Entry : PointerParents) { for (const auto &Entry : PointerParents) {
if (Entry.second.is<ast_type_traits::DynTypedNode *>()) { if (Entry.second.is<DynTypedNode *>()) {
delete Entry.second.get<ast_type_traits::DynTypedNode *>(); delete Entry.second.get<DynTypedNode *>();
} else if (Entry.second.is<ParentVector *>()) { } else if (Entry.second.is<ParentVector *>()) {
delete Entry.second.get<ParentVector *>(); delete Entry.second.get<ParentVector *>();
} }
} }
for (const auto &Entry : OtherParents) { for (const auto &Entry : OtherParents) {
if (Entry.second.is<ast_type_traits::DynTypedNode *>()) { if (Entry.second.is<DynTypedNode *>()) {
delete Entry.second.get<ast_type_traits::DynTypedNode *>(); delete Entry.second.get<DynTypedNode *>();
} else if (Entry.second.is<ParentVector *>()) { } else if (Entry.second.is<ParentVector *>()) {
delete Entry.second.get<ParentVector *>(); delete Entry.second.get<ParentVector *>();
} }
} }
} }
DynTypedNodeList getParents(ast_type_traits::TraversalKind TK, DynTypedNodeList getParents(TraversalKind TK, const DynTypedNode &Node) {
const ast_type_traits::DynTypedNode &Node) {
if (Node.getNodeKind().hasPointerIdentity()) { if (Node.getNodeKind().hasPointerIdentity()) {
auto ParentList = auto ParentList =
getDynNodeFromMap(Node.getMemoizationData(), PointerParents); getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
if (ParentList.size() == 1 && if (ParentList.size() == 1 && TK == TK_IgnoreUnlessSpelledInSource) {
TK == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
const auto *E = ParentList[0].get<Expr>(); const auto *E = ParentList[0].get<Expr>();
const auto *Child = Node.get<Expr>(); const auto *Child = Node.get<Expr>();
if (E && Child) if (E && Child)
@ -186,28 +183,25 @@ public:
} }
const auto *P = dyn_cast<Expr>(S); const auto *P = dyn_cast<Expr>(S);
if (!P) if (!P)
return ast_type_traits::DynTypedNode::create(*S); return DynTypedNode::create(*S);
Child = E; Child = E;
E = P; E = P;
} }
return ast_type_traits::DynTypedNode::create(*E); return DynTypedNode::create(*E);
} }
}; };
/// Template specializations to abstract away from pointers and TypeLocs. /// Template specializations to abstract away from pointers and TypeLocs.
/// @{ /// @{
template <typename T> template <typename T> static DynTypedNode createDynTypedNode(const T &Node) {
static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) { return DynTypedNode::create(*Node);
return ast_type_traits::DynTypedNode::create(*Node); }
template <> DynTypedNode createDynTypedNode(const TypeLoc &Node) {
return DynTypedNode::create(Node);
} }
template <> template <>
ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) { DynTypedNode createDynTypedNode(const NestedNameSpecifierLoc &Node) {
return ast_type_traits::DynTypedNode::create(Node); return DynTypedNode::create(Node);
}
template <>
ast_type_traits::DynTypedNode
createDynTypedNode(const NestedNameSpecifierLoc &Node) {
return ast_type_traits::DynTypedNode::create(Node);
} }
/// @} /// @}
@ -257,13 +251,12 @@ private:
else if (const auto *S = ParentStack.back().get<Stmt>()) else if (const auto *S = ParentStack.back().get<Stmt>())
NodeOrVector = S; NodeOrVector = S;
else else
NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back()); NodeOrVector = new DynTypedNode(ParentStack.back());
} else { } else {
if (!NodeOrVector.template is<ParentVector *>()) { if (!NodeOrVector.template is<ParentVector *>()) {
auto *Vector = new ParentVector( auto *Vector = new ParentVector(
1, getSingleDynTypedNodeFromParentMap(NodeOrVector)); 1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
delete NodeOrVector delete NodeOrVector.template dyn_cast<DynTypedNode *>();
.template dyn_cast<ast_type_traits::DynTypedNode *>();
NodeOrVector = Vector; NodeOrVector = Vector;
} }
@ -299,28 +292,27 @@ private:
bool TraverseTypeLoc(TypeLoc TypeLocNode) { bool TraverseTypeLoc(TypeLoc TypeLocNode) {
return TraverseNode( return TraverseNode(
TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode), TypeLocNode, DynTypedNode::create(TypeLocNode),
[&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); }, [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
&Map.OtherParents); &Map.OtherParents);
} }
bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) { bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
return TraverseNode( return TraverseNode(
NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode), NNSLocNode, DynTypedNode::create(NNSLocNode),
[&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); }, [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
&Map.OtherParents); &Map.OtherParents);
} }
ParentMap &Map; ParentMap &Map;
llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack; llvm::SmallVector<DynTypedNode, 16> ParentStack;
}; };
ParentMapContext::ParentMap::ParentMap(ASTContext &Ctx) { ParentMapContext::ParentMap::ParentMap(ASTContext &Ctx) {
ASTVisitor(*this).TraverseAST(Ctx); ASTVisitor(*this).TraverseAST(Ctx);
} }
DynTypedNodeList DynTypedNodeList ParentMapContext::getParents(const DynTypedNode &Node) {
ParentMapContext::getParents(const ast_type_traits::DynTypedNode &Node) {
if (!Parents) if (!Parents)
// We build the parent map for the traversal scope (usually whole TU), as // We build the parent map for the traversal scope (usually whole TU), as
// hasAncestor can escape any subtree. // hasAncestor can escape any subtree.

83
clang/lib/ASTMatchers/ASTMatchFinder.cpp
View File

@ -57,9 +57,9 @@ static const unsigned MaxMemoizationEntries = 10000;
// provides enough benefit for the additional amount of code. // provides enough benefit for the additional amount of code.
struct MatchKey { struct MatchKey {
DynTypedMatcher::MatcherIDType MatcherID; DynTypedMatcher::MatcherIDType MatcherID;
ast_type_traits::DynTypedNode Node; DynTypedNode Node;
BoundNodesTreeBuilder BoundNodes; BoundNodesTreeBuilder BoundNodes;
ast_type_traits::TraversalKind Traversal = ast_type_traits::TK_AsIs; TraversalKind Traversal = TK_AsIs;
bool operator<(const MatchKey &Other) const { bool operator<(const MatchKey &Other) const {
return std::tie(Traversal, MatcherID, Node, BoundNodes) < return std::tie(Traversal, MatcherID, Node, BoundNodes) <
@ -87,8 +87,7 @@ public:
// matching the descendants. // matching the descendants.
MatchChildASTVisitor(const DynTypedMatcher *Matcher, ASTMatchFinder *Finder, MatchChildASTVisitor(const DynTypedMatcher *Matcher, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, int MaxDepth, BoundNodesTreeBuilder *Builder, int MaxDepth,
ast_type_traits::TraversalKind Traversal, TraversalKind Traversal, ASTMatchFinder::BindKind Bind)
ASTMatchFinder::BindKind Bind)
: Matcher(Matcher), Finder(Finder), Builder(Builder), CurrentDepth(0), : Matcher(Matcher), Finder(Finder), Builder(Builder), CurrentDepth(0),
MaxDepth(MaxDepth), Traversal(Traversal), Bind(Bind), Matches(false) {} MaxDepth(MaxDepth), Traversal(Traversal), Bind(Bind), Matches(false) {}
@ -103,7 +102,7 @@ public:
// Traverse*(c) for each child c of 'node'. // Traverse*(c) for each child c of 'node'.
// - Traverse*(c) in turn calls Traverse(c), completing the // - Traverse*(c) in turn calls Traverse(c), completing the
// recursion. // recursion.
bool findMatch(const ast_type_traits::DynTypedNode &DynNode) { bool findMatch(const DynTypedNode &DynNode) {
reset(); reset();
if (const Decl *D = DynNode.get<Decl>()) if (const Decl *D = DynNode.get<Decl>())
traverse(*D); traverse(*D);
@ -145,15 +144,14 @@ public:
auto *LambdaNode = dyn_cast_or_null<LambdaExpr>(StmtNode); auto *LambdaNode = dyn_cast_or_null<LambdaExpr>(StmtNode);
if (LambdaNode && if (LambdaNode &&
Finder->getASTContext().getParentMapContext().getTraversalKind() == Finder->getASTContext().getParentMapContext().getTraversalKind() ==
ast_type_traits::TK_IgnoreUnlessSpelledInSource) TK_IgnoreUnlessSpelledInSource)
StmtToTraverse = LambdaNode; StmtToTraverse = LambdaNode;
else else
StmtToTraverse = StmtToTraverse =
Finder->getASTContext().getParentMapContext().traverseIgnored( Finder->getASTContext().getParentMapContext().traverseIgnored(
ExprNode); ExprNode);
} }
if (Traversal == if (Traversal == TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode)) if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
StmtToTraverse = ExprNode->IgnoreParenImpCasts(); StmtToTraverse = ExprNode->IgnoreParenImpCasts();
} }
@ -220,7 +218,7 @@ public:
} }
bool TraverseLambdaExpr(LambdaExpr *Node) { bool TraverseLambdaExpr(LambdaExpr *Node) {
if (Finder->getASTContext().getParentMapContext().getTraversalKind() != if (Finder->getASTContext().getParentMapContext().getTraversalKind() !=
ast_type_traits::TK_IgnoreUnlessSpelledInSource) TK_IgnoreUnlessSpelledInSource)
return VisitorBase::TraverseLambdaExpr(Node); return VisitorBase::TraverseLambdaExpr(Node);
if (!Node) if (!Node)
return true; return true;
@ -311,7 +309,7 @@ private:
} }
if (Bind != ASTMatchFinder::BK_All) { if (Bind != ASTMatchFinder::BK_All) {
BoundNodesTreeBuilder RecursiveBuilder(*Builder); BoundNodesTreeBuilder RecursiveBuilder(*Builder);
if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder, if (Matcher->matches(DynTypedNode::create(Node), Finder,
&RecursiveBuilder)) { &RecursiveBuilder)) {
Matches = true; Matches = true;
ResultBindings.addMatch(RecursiveBuilder); ResultBindings.addMatch(RecursiveBuilder);
@ -319,7 +317,7 @@ private:
} }
} else { } else {
BoundNodesTreeBuilder RecursiveBuilder(*Builder); BoundNodesTreeBuilder RecursiveBuilder(*Builder);
if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder, if (Matcher->matches(DynTypedNode::create(Node), Finder,
&RecursiveBuilder)) { &RecursiveBuilder)) {
// After the first match the matcher succeeds. // After the first match the matcher succeeds.
Matches = true; Matches = true;
@ -346,7 +344,7 @@ private:
BoundNodesTreeBuilder ResultBindings; BoundNodesTreeBuilder ResultBindings;
int CurrentDepth; int CurrentDepth;
const int MaxDepth; const int MaxDepth;
const ast_type_traits::TraversalKind Traversal; const TraversalKind Traversal;
const ASTMatchFinder::BindKind Bind; const ASTMatchFinder::BindKind Bind;
bool Matches; bool Matches;
}; };
@ -443,12 +441,10 @@ public:
bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit); bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit);
// Matches children or descendants of 'Node' with 'BaseMatcher'. // Matches children or descendants of 'Node' with 'BaseMatcher'.
bool memoizedMatchesRecursively(const ast_type_traits::DynTypedNode &Node, bool memoizedMatchesRecursively(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx,
const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, int MaxDepth, BoundNodesTreeBuilder *Builder, int MaxDepth,
ast_type_traits::TraversalKind Traversal, TraversalKind Traversal, BindKind Bind) {
BindKind Bind) {
// For AST-nodes that don't have an identity, we can't memoize. // For AST-nodes that don't have an identity, we can't memoize.
if (!Node.getMemoizationData() || !Builder->isComparable()) if (!Node.getMemoizationData() || !Builder->isComparable())
return matchesRecursively(Node, Matcher, Builder, MaxDepth, Traversal, return matchesRecursively(Node, Matcher, Builder, MaxDepth, Traversal,
@ -480,11 +476,10 @@ public:
} }
// Matches children or descendants of 'Node' with 'BaseMatcher'. // Matches children or descendants of 'Node' with 'BaseMatcher'.
bool matchesRecursively(const ast_type_traits::DynTypedNode &Node, bool matchesRecursively(const DynTypedNode &Node,
const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, int MaxDepth, BoundNodesTreeBuilder *Builder, int MaxDepth,
ast_type_traits::TraversalKind Traversal, TraversalKind Traversal, BindKind Bind) {
BindKind Bind) {
MatchChildASTVisitor Visitor( MatchChildASTVisitor Visitor(
&Matcher, this, Builder, MaxDepth, Traversal, Bind); &Matcher, this, Builder, MaxDepth, Traversal, Bind);
return Visitor.findMatch(Node); return Visitor.findMatch(Node);
@ -501,10 +496,9 @@ public:
bool Directly) override; bool Directly) override;
// Implements ASTMatchFinder::matchesChildOf. // Implements ASTMatchFinder::matchesChildOf.
bool matchesChildOf(const ast_type_traits::DynTypedNode &Node, bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx, const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder, TraversalKind Traversal,
ast_type_traits::TraversalKind Traversal,
BindKind Bind) override { BindKind Bind) override {
if (ResultCache.size() > MaxMemoizationEntries) if (ResultCache.size() > MaxMemoizationEntries)
ResultCache.clear(); ResultCache.clear();
@ -512,19 +506,18 @@ public:
Bind); Bind);
} }
// Implements ASTMatchFinder::matchesDescendantOf. // Implements ASTMatchFinder::matchesDescendantOf.
bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node, bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx, const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
BindKind Bind) override { BindKind Bind) override {
if (ResultCache.size() > MaxMemoizationEntries) if (ResultCache.size() > MaxMemoizationEntries)
ResultCache.clear(); ResultCache.clear();
return memoizedMatchesRecursively(Node, Ctx, Matcher, Builder, INT_MAX, return memoizedMatchesRecursively(Node, Ctx, Matcher, Builder, INT_MAX,
ast_type_traits::TraversalKind::TK_AsIs, TraversalKind::TK_AsIs, Bind);
Bind);
} }
// Implements ASTMatchFinder::matchesAncestorOf. // Implements ASTMatchFinder::matchesAncestorOf.
bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node, bool matchesAncestorOf(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx, const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
AncestorMatchMode MatchMode) override { AncestorMatchMode MatchMode) override {
// Reset the cache outside of the recursive call to make sure we // Reset the cache outside of the recursive call to make sure we
@ -537,7 +530,7 @@ public:
// Matches all registered matchers on the given node and calls the // Matches all registered matchers on the given node and calls the
// result callback for every node that matches. // result callback for every node that matches.
void match(const ast_type_traits::DynTypedNode &Node) { void match(const DynTypedNode &Node) {
// FIXME: Improve this with a switch or a visitor pattern. // FIXME: Improve this with a switch or a visitor pattern.
if (auto *N = Node.get<Decl>()) { if (auto *N = Node.get<Decl>()) {
match(*N); match(*N);
@ -615,7 +608,7 @@ private:
} }
} }
void matchWithFilter(const ast_type_traits::DynTypedNode &DynNode) { void matchWithFilter(const DynTypedNode &DynNode) {
auto Kind = DynNode.getNodeKind(); auto Kind = DynNode.getNodeKind();
auto it = MatcherFiltersMap.find(Kind); auto it = MatcherFiltersMap.find(Kind);
const auto &Filter = const auto &Filter =
@ -639,8 +632,7 @@ private:
} }
} }
const std::vector<unsigned short> & const std::vector<unsigned short> &getFilterForKind(ASTNodeKind Kind) {
getFilterForKind(ast_type_traits::ASTNodeKind Kind) {
auto &Filter = MatcherFiltersMap[Kind]; auto &Filter = MatcherFiltersMap[Kind];
auto &Matchers = this->Matchers->DeclOrStmt; auto &Matchers = this->Matchers->DeclOrStmt;
assert((Matchers.size() < USHRT_MAX) && "Too many matchers."); assert((Matchers.size() < USHRT_MAX) && "Too many matchers.");
@ -655,10 +647,10 @@ private:
/// @{ /// @{
/// Overloads to pair the different node types to their matchers. /// Overloads to pair the different node types to their matchers.
void matchDispatch(const Decl *Node) { void matchDispatch(const Decl *Node) {
return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node)); return matchWithFilter(DynTypedNode::create(*Node));
} }
void matchDispatch(const Stmt *Node) { void matchDispatch(const Stmt *Node) {
return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node)); return matchWithFilter(DynTypedNode::create(*Node));
} }
void matchDispatch(const Type *Node) { void matchDispatch(const Type *Node) {
@ -695,9 +687,10 @@ private:
// Once there are multiple parents, the breadth first search order does not // Once there are multiple parents, the breadth first search order does not
// allow simple memoization on the ancestors. Thus, we only memoize as long // allow simple memoization on the ancestors. Thus, we only memoize as long
// as there is a single parent. // as there is a single parent.
bool memoizedMatchesAncestorOfRecursively( bool memoizedMatchesAncestorOfRecursively(const DynTypedNode &Node,
const ast_type_traits::DynTypedNode &Node, ASTContext &Ctx, ASTContext &Ctx,
const DynTypedMatcher &Matcher, BoundNodesTreeBuilder *Builder, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder,
AncestorMatchMode MatchMode) { AncestorMatchMode MatchMode) {
// For AST-nodes that don't have an identity, we can't memoize. // For AST-nodes that don't have an identity, we can't memoize.
if (!Builder->isComparable()) if (!Builder->isComparable())
@ -730,8 +723,7 @@ private:
return CachedResult.ResultOfMatch; return CachedResult.ResultOfMatch;
} }
bool matchesAncestorOfRecursively(const ast_type_traits::DynTypedNode &Node, bool matchesAncestorOfRecursively(const DynTypedNode &Node, ASTContext &Ctx,
ASTContext &Ctx,
const DynTypedMatcher &Matcher, const DynTypedMatcher &Matcher,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
AncestorMatchMode MatchMode) { AncestorMatchMode MatchMode) {
@ -758,7 +750,7 @@ private:
} }
if (Parents.size() == 1) { if (Parents.size() == 1) {
// Only one parent - do recursive memoization. // Only one parent - do recursive memoization.
const ast_type_traits::DynTypedNode Parent = Parents[0]; const DynTypedNode Parent = Parents[0];
BoundNodesTreeBuilder BuilderCopy = *Builder; BoundNodesTreeBuilder BuilderCopy = *Builder;
if (Matcher.matches(Parent, this, &BuilderCopy)) { if (Matcher.matches(Parent, this, &BuilderCopy)) {
*Builder = std::move(BuilderCopy); *Builder = std::move(BuilderCopy);
@ -773,8 +765,7 @@ private:
} else { } else {
// Multiple parents - BFS over the rest of the nodes. // Multiple parents - BFS over the rest of the nodes.
llvm::DenseSet<const void *> Visited; llvm::DenseSet<const void *> Visited;
std::deque<ast_type_traits::DynTypedNode> Queue(Parents.begin(), std::deque<DynTypedNode> Queue(Parents.begin(), Parents.end());
Parents.end());
while (!Queue.empty()) { while (!Queue.empty()) {
BoundNodesTreeBuilder BuilderCopy = *Builder; BoundNodesTreeBuilder BuilderCopy = *Builder;
if (Matcher.matches(Queue.front(), this, &BuilderCopy)) { if (Matcher.matches(Queue.front(), this, &BuilderCopy)) {
@ -864,8 +855,7 @@ private:
/// kind (and derived kinds) so it is a waste to try every matcher on every /// kind (and derived kinds) so it is a waste to try every matcher on every
/// node. /// node.
/// We precalculate a list of matchers that pass the toplevel restrict check. /// We precalculate a list of matchers that pass the toplevel restrict check.
llvm::DenseMap<ast_type_traits::ASTNodeKind, std::vector<unsigned short>> llvm::DenseMap<ASTNodeKind, std::vector<unsigned short>> MatcherFiltersMap;
MatcherFiltersMap;
const MatchFinder::MatchFinderOptions &Options; const MatchFinder::MatchFinderOptions &Options;
ASTContext *ActiveASTContext; ASTContext *ActiveASTContext;
@ -1140,8 +1130,7 @@ std::unique_ptr<ASTConsumer> MatchFinder::newASTConsumer() {
return std::make_unique<internal::MatchASTConsumer>(this, ParsingDone); return std::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
} }
void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node, void MatchFinder::match(const clang::DynTypedNode &Node, ASTContext &Context) {
ASTContext &Context) {
internal::MatchASTVisitor Visitor(&Matchers, Options); internal::MatchASTVisitor Visitor(&Matchers, Options);
Visitor.set_active_ast_context(&Context); Visitor.set_active_ast_context(&Context);
Visitor.match(Node); Visitor.match(Node);

87
clang/lib/ASTMatchers/ASTMatchersInternal.cpp
View File

@ -51,26 +51,23 @@ AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
namespace internal { namespace internal {
bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode, bool NotUnaryOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers);
bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers); ArrayRef<DynTypedMatcher> InnerMatchers);
bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool AllOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers); ArrayRef<DynTypedMatcher> InnerMatchers);
bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool EachOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers); ArrayRef<DynTypedMatcher> InnerMatchers);
bool OptionallyVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool AnyOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers);
bool OptionallyVariadicOperator(const DynTypedNode &DynNode,
ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers); ArrayRef<DynTypedMatcher> InnerMatchers);
@ -86,7 +83,7 @@ void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) {
namespace { namespace {
using VariadicOperatorFunction = bool (*)( using VariadicOperatorFunction = bool (*)(
const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, const DynTypedNode &DynNode, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers); BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
template <VariadicOperatorFunction Func> template <VariadicOperatorFunction Func>
@ -95,8 +92,7 @@ public:
VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers) VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers)
: InnerMatchers(std::move(InnerMatchers)) {} : InnerMatchers(std::move(InnerMatchers)) {}
bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
return Func(DynNode, Finder, Builder, InnerMatchers); return Func(DynNode, Finder, Builder, InnerMatchers);
} }
@ -111,16 +107,14 @@ public:
IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher) IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
: ID(ID), InnerMatcher(std::move(InnerMatcher)) {} : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
bool dynMatches(const ast_type_traits::DynTypedNode &DynNode, bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const override { BoundNodesTreeBuilder *Builder) const override {
bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder); bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
if (Result) Builder->setBinding(ID, DynNode); if (Result) Builder->setBinding(ID, DynNode);
return Result; return Result;
} }
llvm::Optional<ast_type_traits::TraversalKind> llvm::Optional<clang::TraversalKind> TraversalKind() const override {
TraversalKind() const override {
return InnerMatcher->TraversalKind(); return InnerMatcher->TraversalKind();
} }
@ -140,7 +134,7 @@ public:
Retain(); // Reference count will never become zero. Retain(); // Reference count will never become zero.
} }
bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *, bool dynMatches(const DynTypedNode &, ASTMatchFinder *,
BoundNodesTreeBuilder *) const override { BoundNodesTreeBuilder *) const override {
return true; return true;
} }
@ -150,9 +144,9 @@ public:
static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance; static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance;
DynTypedMatcher DynTypedMatcher::constructVariadic( DynTypedMatcher
DynTypedMatcher::VariadicOperator Op, DynTypedMatcher::constructVariadic(DynTypedMatcher::VariadicOperator Op,
ast_type_traits::ASTNodeKind SupportedKind, ASTNodeKind SupportedKind,
std::vector<DynTypedMatcher> InnerMatchers) { std::vector<DynTypedMatcher> InnerMatchers) {
assert(!InnerMatchers.empty() && "Array must not be empty."); assert(!InnerMatchers.empty() && "Array must not be empty.");
assert(llvm::all_of(InnerMatchers, assert(llvm::all_of(InnerMatchers,
@ -174,8 +168,8 @@ DynTypedMatcher DynTypedMatcher::constructVariadic(
// invalid types earlier and we can elide the kind checks inside the // invalid types earlier and we can elide the kind checks inside the
// matcher. // matcher.
for (auto &IM : InnerMatchers) { for (auto &IM : InnerMatchers) {
RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType( RestrictKind =
RestrictKind, IM.RestrictKind); ASTNodeKind::getMostDerivedType(RestrictKind, IM.RestrictKind);
} }
return DynTypedMatcher( return DynTypedMatcher(
SupportedKind, RestrictKind, SupportedKind, RestrictKind,
@ -206,34 +200,30 @@ DynTypedMatcher DynTypedMatcher::constructVariadic(
llvm_unreachable("Invalid Op value."); llvm_unreachable("Invalid Op value.");
} }
DynTypedMatcher DynTypedMatcher::constructRestrictedWrapper( DynTypedMatcher
const DynTypedMatcher &InnerMatcher, DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
ast_type_traits::ASTNodeKind RestrictKind) { ASTNodeKind RestrictKind) {
DynTypedMatcher Copy = InnerMatcher; DynTypedMatcher Copy = InnerMatcher;
Copy.RestrictKind = RestrictKind; Copy.RestrictKind = RestrictKind;
return Copy; return Copy;
} }
DynTypedMatcher DynTypedMatcher::trueMatcher( DynTypedMatcher DynTypedMatcher::trueMatcher(ASTNodeKind NodeKind) {
ast_type_traits::ASTNodeKind NodeKind) {
return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance); return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance);
} }
bool DynTypedMatcher::canMatchNodesOfKind( bool DynTypedMatcher::canMatchNodesOfKind(ASTNodeKind Kind) const {
ast_type_traits::ASTNodeKind Kind) const {
return RestrictKind.isBaseOf(Kind); return RestrictKind.isBaseOf(Kind);
} }
DynTypedMatcher DynTypedMatcher::dynCastTo( DynTypedMatcher DynTypedMatcher::dynCastTo(const ASTNodeKind Kind) const {
const ast_type_traits::ASTNodeKind Kind) const {
auto Copy = *this; auto Copy = *this;
Copy.SupportedKind = Kind; Copy.SupportedKind = Kind;
Copy.RestrictKind = Copy.RestrictKind = ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
return Copy; return Copy;
} }
bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode, bool DynTypedMatcher::matches(const DynTypedNode &DynNode,
ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const { BoundNodesTreeBuilder *Builder) const {
TraversalKindScope RAII(Finder->getASTContext(), TraversalKindScope RAII(Finder->getASTContext(),
@ -253,8 +243,8 @@ bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode,
return false; return false;
} }
bool DynTypedMatcher::matchesNoKindCheck( bool DynTypedMatcher::matchesNoKindCheck(const DynTypedNode &DynNode,
const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder) const { BoundNodesTreeBuilder *Builder) const {
TraversalKindScope raii(Finder->getASTContext(), TraversalKindScope raii(Finder->getASTContext(),
Implementation->TraversalKind()); Implementation->TraversalKind());
@ -281,10 +271,10 @@ llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
return std::move(Result); return std::move(Result);
} }
bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const { bool DynTypedMatcher::canConvertTo(ASTNodeKind To) const {
const auto From = getSupportedKind(); const auto From = getSupportedKind();
auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>(); auto QualKind = ASTNodeKind::getFromNodeKind<QualType>();
auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>(); auto TypeKind = ASTNodeKind::getFromNodeKind<Type>();
/// Mimic the implicit conversions of Matcher<>. /// Mimic the implicit conversions of Matcher<>.
/// - From Matcher<Type> to Matcher<QualType> /// - From Matcher<Type> to Matcher<QualType>
if (From.isSame(TypeKind) && To.isSame(QualKind)) return true; if (From.isSame(TypeKind) && To.isSame(QualKind)) return true;
@ -296,8 +286,8 @@ void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) {
Bindings.append(Other.Bindings.begin(), Other.Bindings.end()); Bindings.append(Other.Bindings.begin(), Other.Bindings.end());
} }
bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode, bool NotUnaryOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers) { ArrayRef<DynTypedMatcher> InnerMatchers) {
if (InnerMatchers.size() != 1) if (InnerMatchers.size() != 1)
return false; return false;
@ -316,8 +306,7 @@ bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
return !InnerMatchers[0].matches(DynNode, Finder, &Discard); return !InnerMatchers[0].matches(DynNode, Finder, &Discard);
} }
bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool AllOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers) { ArrayRef<DynTypedMatcher> InnerMatchers) {
// allOf leads to one matcher for each alternative in the first // allOf leads to one matcher for each alternative in the first
@ -330,8 +319,7 @@ bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
return true; return true;
} }
bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool EachOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers) { ArrayRef<DynTypedMatcher> InnerMatchers) {
BoundNodesTreeBuilder Result; BoundNodesTreeBuilder Result;
@ -347,8 +335,7 @@ bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
return Matched; return Matched;
} }
bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool AnyOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers) { ArrayRef<DynTypedMatcher> InnerMatchers) {
for (const DynTypedMatcher &InnerMatcher : InnerMatchers) { for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
@ -361,7 +348,7 @@ bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
return false; return false;
} }
bool OptionallyVariadicOperator(const ast_type_traits::DynTypedNode &DynNode, bool OptionallyVariadicOperator(const DynTypedNode &DynNode,
ASTMatchFinder *Finder, ASTMatchFinder *Finder,
BoundNodesTreeBuilder *Builder, BoundNodesTreeBuilder *Builder,
ArrayRef<DynTypedMatcher> InnerMatchers) { ArrayRef<DynTypedMatcher> InnerMatchers) {

91
clang/lib/ASTMatchers/Dynamic/Marshallers.h
View File

@ -80,7 +80,7 @@ template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T>> {
} }
static ArgKind getKind() { static ArgKind getKind() {
return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); return ArgKind(ASTNodeKind::getFromNodeKind<T>());
} }
}; };
@ -211,7 +211,7 @@ public:
/// set of argument types accepted for argument \p ArgNo to \p ArgKinds. /// set of argument types accepted for argument \p ArgNo to \p ArgKinds.
// FIXME: We should provide the ability to constrain the output of this // FIXME: We should provide the ability to constrain the output of this
// function based on the types of other matcher arguments. // function based on the types of other matcher arguments.
virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, virtual void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &ArgKinds) const = 0; std::vector<ArgKind> &ArgKinds) const = 0;
/// Returns whether this matcher is convertible to the given type. If it is /// Returns whether this matcher is convertible to the given type. If it is
@ -221,20 +221,19 @@ public:
/// same matcher overload. Zero specificity indicates that this conversion /// same matcher overload. Zero specificity indicates that this conversion
/// would produce a trivial matcher that will either always or never match. /// would produce a trivial matcher that will either always or never match.
/// Such matchers are excluded from code completion results. /// Such matchers are excluded from code completion results.
virtual bool isConvertibleTo( virtual bool
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity = nullptr, isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity = nullptr,
ast_type_traits::ASTNodeKind *LeastDerivedKind = nullptr) const = 0; ASTNodeKind *LeastDerivedKind = nullptr) const = 0;
/// Returns whether the matcher will, given a matcher of any type T, yield a /// Returns whether the matcher will, given a matcher of any type T, yield a
/// matcher of type T. /// matcher of type T.
virtual bool isPolymorphic() const { return false; } virtual bool isPolymorphic() const { return false; }
}; };
inline bool isRetKindConvertibleTo( inline bool isRetKindConvertibleTo(ArrayRef<ASTNodeKind> RetKinds,
ArrayRef<ast_type_traits::ASTNodeKind> RetKinds, ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ASTNodeKind *LeastDerivedKind) {
ast_type_traits::ASTNodeKind *LeastDerivedKind) { for (const ASTNodeKind &NodeKind : RetKinds) {
for (const ast_type_traits::ASTNodeKind &NodeKind : RetKinds) {
if (ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) { if (ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) {
if (LeastDerivedKind) if (LeastDerivedKind)
*LeastDerivedKind = NodeKind; *LeastDerivedKind = NodeKind;
@ -264,9 +263,9 @@ public:
/// \param RetKinds The list of matcher types to which the matcher is /// \param RetKinds The list of matcher types to which the matcher is
/// convertible. /// convertible.
/// \param ArgKinds The types of the arguments this matcher takes. /// \param ArgKinds The types of the arguments this matcher takes.
FixedArgCountMatcherDescriptor( FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void (*Func)(),
MarshallerType Marshaller, void (*Func)(), StringRef MatcherName, StringRef MatcherName,
ArrayRef<ast_type_traits::ASTNodeKind> RetKinds, ArrayRef<ASTNodeKind> RetKinds,
ArrayRef<ArgKind> ArgKinds) ArrayRef<ArgKind> ArgKinds)
: Marshaller(Marshaller), Func(Func), MatcherName(MatcherName), : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
RetKinds(RetKinds.begin(), RetKinds.end()), RetKinds(RetKinds.begin(), RetKinds.end()),
@ -281,14 +280,13 @@ public:
bool isVariadic() const override { return false; } bool isVariadic() const override { return false; }
unsigned getNumArgs() const override { return ArgKinds.size(); } unsigned getNumArgs() const override { return ArgKinds.size(); }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const override { std::vector<ArgKind> &Kinds) const override {
Kinds.push_back(ArgKinds[ArgNo]); Kinds.push_back(ArgKinds[ArgNo]);
} }
bool isConvertibleTo( bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ASTNodeKind *LeastDerivedKind) const override {
ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
return isRetKindConvertibleTo(RetKinds, Kind, Specificity, return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
LeastDerivedKind); LeastDerivedKind);
} }
@ -297,7 +295,7 @@ private:
const MarshallerType Marshaller; const MarshallerType Marshaller;
void (* const Func)(); void (* const Func)();
const std::string MatcherName; const std::string MatcherName;
const std::vector<ast_type_traits::ASTNodeKind> RetKinds; const std::vector<ASTNodeKind> RetKinds;
const std::vector<ArgKind> ArgKinds; const std::vector<ArgKind> ArgKinds;
}; };
@ -336,36 +334,35 @@ static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
} }
template <typename T> template <typename T>
inline void buildReturnTypeVectorFromTypeList( inline void
std::vector<ast_type_traits::ASTNodeKind> &RetTypes) { buildReturnTypeVectorFromTypeList(std::vector<ASTNodeKind> &RetTypes) {
RetTypes.push_back( RetTypes.push_back(ASTNodeKind::getFromNodeKind<typename T::head>());
ast_type_traits::ASTNodeKind::getFromNodeKind<typename T::head>());
buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes); buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
} }
template <> template <>
inline void inline void
buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>( buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {} std::vector<ASTNodeKind> &RetTypes) {}
template <typename T> template <typename T>
struct BuildReturnTypeVector { struct BuildReturnTypeVector {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) { static void build(std::vector<ASTNodeKind> &RetTypes) {
buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes); buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
} }
}; };
template <typename T> template <typename T>
struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T>> { struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T>> {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) { static void build(std::vector<ASTNodeKind> &RetTypes) {
RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
} }
}; };
template <typename T> template <typename T>
struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T>> { struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T>> {
static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) { static void build(std::vector<ASTNodeKind> &RetTypes) {
RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()); RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
} }
}; };
@ -439,14 +436,13 @@ public:
bool isVariadic() const override { return true; } bool isVariadic() const override { return true; }
unsigned getNumArgs() const override { return 0; } unsigned getNumArgs() const override { return 0; }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const override { std::vector<ArgKind> &Kinds) const override {
Kinds.push_back(ArgsKind); Kinds.push_back(ArgsKind);
} }
bool isConvertibleTo( bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ASTNodeKind *LeastDerivedKind) const override {
ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
return isRetKindConvertibleTo(RetKinds, Kind, Specificity, return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
LeastDerivedKind); LeastDerivedKind);
} }
@ -454,7 +450,7 @@ public:
private: private:
const RunFunc Func; const RunFunc Func;
const std::string MatcherName; const std::string MatcherName;
std::vector<ast_type_traits::ASTNodeKind> RetKinds; std::vector<ASTNodeKind> RetKinds;
const ArgKind ArgsKind; const ArgKind ArgsKind;
}; };
@ -466,12 +462,10 @@ public:
ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func, ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
StringRef MatcherName) StringRef MatcherName)
: VariadicFuncMatcherDescriptor(Func, MatcherName), : VariadicFuncMatcherDescriptor(Func, MatcherName),
DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) { DerivedKind(ASTNodeKind::getFromNodeKind<DerivedT>()) {}
}
bool bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ASTNodeKind *LeastDerivedKind) const override {
ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
// If Kind is not a base of DerivedKind, either DerivedKind is a base of // If Kind is not a base of DerivedKind, either DerivedKind is a base of
// Kind (in which case the match will always succeed) or Kind and // Kind (in which case the match will always succeed) or Kind and
// DerivedKind are unrelated (in which case it will always fail), so set // DerivedKind are unrelated (in which case it will always fail), so set
@ -489,7 +483,7 @@ public:
} }
private: private:
const ast_type_traits::ASTNodeKind DerivedKind; const ASTNodeKind DerivedKind;
}; };
/// Helper macros to check the arguments on all marshaller functions. /// Helper macros to check the arguments on all marshaller functions.
@ -635,7 +629,7 @@ public:
return Overload0NumArgs; return Overload0NumArgs;
} }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const override { std::vector<ArgKind> &Kinds) const override {
for (const auto &O : Overloads) { for (const auto &O : Overloads) {
if (O->isConvertibleTo(ThisKind)) if (O->isConvertibleTo(ThisKind))
@ -643,9 +637,8 @@ public:
} }
} }
bool isConvertibleTo( bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, ASTNodeKind *LeastDerivedKind) const override {
ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
for (const auto &O : Overloads) { for (const auto &O : Overloads) {
if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind)) if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
return true; return true;
@ -697,13 +690,13 @@ public:
bool isVariadic() const override { return true; } bool isVariadic() const override { return true; }
unsigned getNumArgs() const override { return 0; } unsigned getNumArgs() const override { return 0; }
void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo, void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
std::vector<ArgKind> &Kinds) const override { std::vector<ArgKind> &Kinds) const override {
Kinds.push_back(ThisKind); Kinds.push_back(ThisKind);
} }
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity, bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
ast_type_traits::ASTNodeKind *LeastDerivedKind) const override { ASTNodeKind *LeastDerivedKind) const override {
if (Specificity) if (Specificity)
*Specificity = 1; *Specificity = 1;
if (LeastDerivedKind) if (LeastDerivedKind)
@ -727,7 +720,7 @@ private:
template <typename ReturnType> template <typename ReturnType>
std::unique_ptr<MatcherDescriptor> std::unique_ptr<MatcherDescriptor>
makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) { makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes; std::vector<ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes); BuildReturnTypeVector<ReturnType>::build(RetTypes);
return std::make_unique<FixedArgCountMatcherDescriptor>( return std::make_unique<FixedArgCountMatcherDescriptor>(
matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func), matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
@ -738,7 +731,7 @@ makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) {
template <typename ReturnType, typename ArgType1> template <typename ReturnType, typename ArgType1>
std::unique_ptr<MatcherDescriptor> std::unique_ptr<MatcherDescriptor>
makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1), StringRef MatcherName) { makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1), StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes; std::vector<ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes); BuildReturnTypeVector<ReturnType>::build(RetTypes);
ArgKind AK = ArgTypeTraits<ArgType1>::getKind(); ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
return std::make_unique<FixedArgCountMatcherDescriptor>( return std::make_unique<FixedArgCountMatcherDescriptor>(
@ -751,7 +744,7 @@ template <typename ReturnType, typename ArgType1, typename ArgType2>
std::unique_ptr<MatcherDescriptor> std::unique_ptr<MatcherDescriptor>
makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2), makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
StringRef MatcherName) { StringRef MatcherName) {
std::vector<ast_type_traits::ASTNodeKind> RetTypes; std::vector<ASTNodeKind> RetTypes;
BuildReturnTypeVector<ReturnType>::build(RetTypes); BuildReturnTypeVector<ReturnType>::build(RetTypes);
ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(), ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
ArgTypeTraits<ArgType2>::getKind() }; ArgTypeTraits<ArgType2>::getKind() };

9
clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
View File

@ -101,8 +101,7 @@ public:
return llvm::None; return llvm::None;
} }
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
unsigned *Specificity) const override {
return ArgKind(Matcher.getSupportedKind()) return ArgKind(Matcher.getSupportedKind())
.isConvertibleTo(Kind, Specificity); .isConvertibleTo(Kind, Specificity);
} }
@ -159,8 +158,7 @@ public:
return llvm::None; return llvm::None;
} }
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
unsigned *Specificity) const override {
unsigned MaxSpecificity = 0; unsigned MaxSpecificity = 0;
for (const DynTypedMatcher &Matcher : Matchers) { for (const DynTypedMatcher &Matcher : Matchers) {
unsigned ThisSpecificity; unsigned ThisSpecificity;
@ -202,8 +200,7 @@ public:
return Ops.constructVariadicOperator(Op, Args); return Ops.constructVariadicOperator(Op, Args);
} }
bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
unsigned *Specificity) const override {
for (const VariantMatcher &Matcher : Args) { for (const VariantMatcher &Matcher : Args) {
if (!Matcher.isConvertibleTo(Kind, Specificity)) if (!Matcher.isConvertibleTo(Kind, Specificity))
return false; return false;

4
clang/lib/Tooling/ASTDiff/ASTDiff.cpp
View File

@ -684,9 +684,7 @@ private:
} }
}; };
ast_type_traits::ASTNodeKind Node::getType() const { ASTNodeKind Node::getType() const { return ASTNode.getNodeKind(); }
return ASTNode.getNodeKind();
}
StringRef Node::getTypeLabel() const { return getType().asStringRef(); } StringRef Node::getTypeLabel() const { return getType().asStringRef(); }

1
clang/lib/Tooling/Refactoring/ASTSelection.cpp
View File

@ -13,7 +13,6 @@
using namespace clang; using namespace clang;
using namespace tooling; using namespace tooling;
using ast_type_traits::DynTypedNode;
namespace { namespace {

6
clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp
View File

@ -427,8 +427,7 @@ public:
StartLoc, StartLoc,
EndLoc, EndLoc,
TemplateSpecType->getTemplateName().getAsTemplateDecl(), TemplateSpecType->getTemplateName().getAsTemplateDecl(),
getClosestAncestorDecl( getClosestAncestorDecl(DynTypedNode::create(TargetLoc)),
ast_type_traits::DynTypedNode::create(TargetLoc)),
GetNestedNameForType(TargetLoc), GetNestedNameForType(TargetLoc),
/*IgnorePrefixQualifers=*/false}; /*IgnorePrefixQualifers=*/false};
RenameInfos.push_back(Info); RenameInfos.push_back(Info);
@ -467,8 +466,7 @@ private:
// FIXME: figure out how to handle it when there are multiple parents. // FIXME: figure out how to handle it when there are multiple parents.
if (Parents.size() != 1) if (Parents.size() != 1)
return nullptr; return nullptr;
if (ast_type_traits::ASTNodeKind::getFromNodeKind<Decl>().isBaseOf( if (ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(Parents[0].getNodeKind()))
Parents[0].getNodeKind()))
return Parents[0].template get<Decl>(); return Parents[0].template get<Decl>();
return getClosestAncestorDecl(Parents[0]); return getClosestAncestorDecl(Parents[0]);
} }

2
clang/lib/Tooling/Transformer/RangeSelector.cpp
View File

@ -23,8 +23,6 @@ using namespace clang;
using namespace transformer; using namespace transformer;
using ast_matchers::MatchFinder; using ast_matchers::MatchFinder;
using ast_type_traits::ASTNodeKind;
using ast_type_traits::DynTypedNode;
using llvm::Error; using llvm::Error;
using llvm::StringError; using llvm::StringError;

1
clang/lib/Tooling/Transformer/RewriteRule.cpp
View File

@ -25,7 +25,6 @@ using namespace transformer;
using ast_matchers::MatchFinder; using ast_matchers::MatchFinder;
using ast_matchers::internal::DynTypedMatcher; using ast_matchers::internal::DynTypedMatcher;
using ast_type_traits::ASTNodeKind;
using MatchResult = MatchFinder::MatchResult; using MatchResult = MatchFinder::MatchResult;

1
clang/lib/Tooling/Transformer/Stencil.cpp
View File

@ -26,7 +26,6 @@ using namespace clang;
using namespace transformer; using namespace transformer;
using ast_matchers::MatchFinder; using ast_matchers::MatchFinder;
using ast_type_traits::DynTypedNode;
using llvm::errc; using llvm::errc;
using llvm::Error; using llvm::Error;
using llvm::Expected; using llvm::Expected;

1
clang/unittests/AST/ASTContextParentMapTest.cpp
View File

@ -89,7 +89,6 @@ TEST(GetParents, RespectsTraversalScope) {
auto &Foo = *TU.lookup(&Ctx.Idents.get("foo")).front(); auto &Foo = *TU.lookup(&Ctx.Idents.get("foo")).front();
auto &Bar = *cast<DeclContext>(Foo).lookup(&Ctx.Idents.get("bar")).front(); auto &Bar = *cast<DeclContext>(Foo).lookup(&Ctx.Idents.get("bar")).front();
using ast_type_traits::DynTypedNode;
// Initially, scope is the whole TU. // Initially, scope is the whole TU.
EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo))); EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU))); EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));

82
clang/unittests/AST/ASTTraverserTest.cpp
View File

@ -96,7 +96,7 @@ template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
} }
template <typename... NodeType> template <typename... NodeType>
std::string dumpASTString(ast_type_traits::TraversalKind TK, NodeType &&... N) { std::string dumpASTString(TraversalKind TK, NodeType &&... N) {
std::string Buffer; std::string Buffer;
llvm::raw_string_ostream OS(Buffer); llvm::raw_string_ostream OS(Buffer);
@ -120,15 +120,13 @@ const FunctionDecl *getFunctionNode(clang::ASTUnit *AST,
template <typename T> struct Verifier { template <typename T> struct Verifier {
static void withDynNode(T Node, const std::string &DumpString) { static void withDynNode(T Node, const std::string &DumpString) {
EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(Node)), EXPECT_EQ(dumpASTString(DynTypedNode::create(Node)), DumpString);
DumpString);
} }
}; };
template <typename T> struct Verifier<T *> { template <typename T> struct Verifier<T *> {
static void withDynNode(T *Node, const std::string &DumpString) { static void withDynNode(T *Node, const std::string &DumpString) {
EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(*Node)), EXPECT_EQ(dumpASTString(DynTypedNode::create(*Node)), DumpString);
DumpString);
} }
}; };
@ -280,7 +278,7 @@ struct MyStruct {
AST->getASTContext()); AST->getASTContext());
EXPECT_EQ(BN.size(), 1u); EXPECT_EQ(BN.size(), 1u);
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
BN[0].getNodeAs<Decl>("ctor")), BN[0].getNodeAs<Decl>("ctor")),
R"cpp( R"cpp(
CXXConstructorDecl 'MyStruct' CXXConstructorDecl 'MyStruct'
@ -289,8 +287,7 @@ CXXConstructorDecl 'MyStruct'
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
)cpp"); )cpp");
EXPECT_EQ( EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("ctor")),
dumpASTString(ast_type_traits::TK_AsIs, BN[0].getNodeAs<Decl>("ctor")),
R"cpp( R"cpp(
CXXConstructorDecl 'MyStruct' CXXConstructorDecl 'MyStruct'
|-ParmVarDecl 'i' |-ParmVarDecl 'i'
@ -321,7 +318,7 @@ void foo()
AST->getASTContext()); AST->getASTContext());
EXPECT_EQ(BN.size(), 1u); EXPECT_EQ(BN.size(), 1u);
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
BN[0].getNodeAs<Decl>("fn")), BN[0].getNodeAs<Decl>("fn")),
R"cpp( R"cpp(
FunctionDecl 'foo' FunctionDecl 'foo'
@ -330,8 +327,7 @@ FunctionDecl 'foo'
`-DeclRefExpr 'someFun' `-DeclRefExpr 'someFun'
)cpp"); )cpp");
EXPECT_EQ( EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
dumpASTString(ast_type_traits::TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
R"cpp( R"cpp(
FunctionDecl 'foo' FunctionDecl 'foo'
`-CompoundStmt `-CompoundStmt
@ -437,7 +433,7 @@ FunctionDecl 'func1'
`-IntegerLiteral `-IntegerLiteral
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, FN), Expected); EXPECT_EQ(dumpASTString(TK_AsIs, FN), Expected);
Expected = R"cpp( Expected = R"cpp(
FunctionDecl 'func1' FunctionDecl 'func1'
@ -445,9 +441,7 @@ FunctionDecl 'func1'
`-ReturnStmt `-ReturnStmt
`-IntegerLiteral `-IntegerLiteral
)cpp"; )cpp";
EXPECT_EQ( EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, FN), Expected);
dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, FN),
Expected);
} }
llvm::StringRef Expected = R"cpp( llvm::StringRef Expected = R"cpp(
@ -457,8 +451,8 @@ FunctionDecl 'func2'
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
`-IntegerLiteral `-IntegerLiteral
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func2")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func2")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -468,8 +462,8 @@ FunctionDecl 'func3'
`-CXXFunctionalCastExpr `-CXXFunctionalCastExpr
`-IntegerLiteral `-IntegerLiteral
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func3")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func3")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -478,8 +472,8 @@ FunctionDecl 'func4'
`-ReturnStmt `-ReturnStmt
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func4")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func4")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -488,8 +482,8 @@ FunctionDecl 'func5'
`-ReturnStmt `-ReturnStmt
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func5")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func5")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -498,8 +492,8 @@ FunctionDecl 'func6'
`-ReturnStmt `-ReturnStmt
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func6")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func6")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -508,8 +502,8 @@ FunctionDecl 'func7'
`-ReturnStmt `-ReturnStmt
`-CXXTemporaryObjectExpr `-CXXTemporaryObjectExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func7")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func7")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -519,8 +513,8 @@ FunctionDecl 'func8'
`-CXXFunctionalCastExpr `-CXXFunctionalCastExpr
`-InitListExpr `-InitListExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func8")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func8")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -530,8 +524,8 @@ FunctionDecl 'func9'
`-CXXFunctionalCastExpr `-CXXFunctionalCastExpr
`-InitListExpr `-InitListExpr
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func9")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func9")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -543,8 +537,8 @@ FunctionDecl 'func10'
`-ReturnStmt `-ReturnStmt
`-DeclRefExpr 'a' `-DeclRefExpr 'a'
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func10")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func10")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -556,8 +550,8 @@ FunctionDecl 'func11'
`-ReturnStmt `-ReturnStmt
`-DeclRefExpr 'b' `-DeclRefExpr 'b'
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func11")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func11")),
Expected); Expected);
Expected = R"cpp( Expected = R"cpp(
@ -569,8 +563,8 @@ FunctionDecl 'func12'
`-ReturnStmt `-ReturnStmt
`-DeclRefExpr 'c' `-DeclRefExpr 'c'
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, EXPECT_EQ(
getFunctionNode("func12")), dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func12")),
Expected); Expected);
} }
@ -629,8 +623,7 @@ LambdaExpr
| `-IntegerLiteral | `-IntegerLiteral
`-CompoundStmt `-CompoundStmt
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L), EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
Expected);
Expected = R"cpp( Expected = R"cpp(
LambdaExpr LambdaExpr
@ -653,7 +646,7 @@ LambdaExpr
|-DeclRefExpr 'f' |-DeclRefExpr 'f'
`-CompoundStmt `-CompoundStmt
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, L), Expected); EXPECT_EQ(dumpASTString(TK_AsIs, L), Expected);
} }
{ {
@ -666,8 +659,7 @@ LambdaExpr
|-ParmVarDecl 't' |-ParmVarDecl 't'
`-CompoundStmt `-CompoundStmt
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L), EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
Expected);
} }
{ {
@ -678,8 +670,7 @@ LambdaExpr
|-CXXThisExpr |-CXXThisExpr
`-CompoundStmt `-CompoundStmt
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L), EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
Expected);
} }
{ {
@ -692,8 +683,7 @@ LambdaExpr
| `-CXXThisExpr | `-CXXThisExpr
`-CompoundStmt `-CompoundStmt
)cpp"; )cpp";
EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L), EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
Expected);
} }
} }

12
clang/unittests/AST/MatchVerifier.h
View File

@ -162,8 +162,8 @@ void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {
} }
template <> template <>
inline void MatchVerifier<ast_type_traits::DynTypedNode>::run( inline void
const MatchFinder::MatchResult &Result) { MatchVerifier<DynTypedNode>::run(const MatchFinder::MatchResult &Result) {
BoundNodes::IDToNodeMap M = Result.Nodes.getMap(); BoundNodes::IDToNodeMap M = Result.Nodes.getMap();
BoundNodes::IDToNodeMap::const_iterator I = M.find(""); BoundNodes::IDToNodeMap::const_iterator I = M.find("");
if (I == M.end()) { if (I == M.end()) {
@ -260,7 +260,7 @@ private:
}; };
/// \brief Verify whether a node's dump contains a given substring. /// \brief Verify whether a node's dump contains a given substring.
class DumpVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> { class DumpVerifier : public MatchVerifier<DynTypedNode> {
public: public:
void expectSubstring(const std::string &Str) { void expectSubstring(const std::string &Str) {
ExpectSubstring = Str; ExpectSubstring = Str;
@ -268,7 +268,7 @@ public:
protected: protected:
void verify(const MatchFinder::MatchResult &Result, void verify(const MatchFinder::MatchResult &Result,
const ast_type_traits::DynTypedNode &Node) override { const DynTypedNode &Node) override {
std::string DumpStr; std::string DumpStr;
llvm::raw_string_ostream Dump(DumpStr); llvm::raw_string_ostream Dump(DumpStr);
Node.dump(Dump, *Result.SourceManager); Node.dump(Dump, *Result.SourceManager);
@ -287,7 +287,7 @@ private:
}; };
/// \brief Verify whether a node's pretty print matches a given string. /// \brief Verify whether a node's pretty print matches a given string.
class PrintVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> { class PrintVerifier : public MatchVerifier<DynTypedNode> {
public: public:
void expectString(const std::string &Str) { void expectString(const std::string &Str) {
ExpectString = Str; ExpectString = Str;
@ -295,7 +295,7 @@ public:
protected: protected:
void verify(const MatchFinder::MatchResult &Result, void verify(const MatchFinder::MatchResult &Result,
const ast_type_traits::DynTypedNode &Node) override { const DynTypedNode &Node) override {
std::string PrintStr; std::string PrintStr;
llvm::raw_string_ostream Print(PrintStr); llvm::raw_string_ostream Print(PrintStr);
Node.print(Print, Result.Context->getPrintingPolicy()); Node.print(Print, Result.Context->getPrintingPolicy());

7
clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp
View File

@ -36,10 +36,9 @@ TEST(HasNameDeathTest, DiesOnEmptyPattern) {
TEST(ConstructVariadic, MismatchedTypes_Regression) { TEST(ConstructVariadic, MismatchedTypes_Regression) {
EXPECT_TRUE( EXPECT_TRUE(
matches("const int a = 0;", matches("const int a = 0;", internal::DynTypedMatcher::constructVariadic(
internal::DynTypedMatcher::constructVariadic(
internal::DynTypedMatcher::VO_AnyOf, internal::DynTypedMatcher::VO_AnyOf,
ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>(), ASTNodeKind::getFromNodeKind<QualType>(),
{isConstQualified(), arrayType()}) {isConstQualified(), arrayType()})
.convertTo<QualType>())); .convertTo<QualType>()));
} }
@ -69,7 +68,7 @@ AST_POLYMORPHIC_MATCHER_P(polymorphicHas,
internal::Matcher<Decl>, AMatcher) { internal::Matcher<Decl>, AMatcher) {
return Finder->matchesChildOf( return Finder->matchesChildOf(
Node, AMatcher, Builder, Node, AMatcher, Builder,
ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses, TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
ASTMatchFinder::BK_First); ASTMatchFinder::BK_First);
} }

193
clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp
View File

@ -1626,70 +1626,56 @@ void foo()
auto Matcher = varDecl(hasInitializer(floatLiteral())); auto Matcher = varDecl(hasInitializer(floatLiteral()));
EXPECT_TRUE( EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, Matcher)));
notMatches(VarDeclCode, traverse(ast_type_traits::TK_AsIs, Matcher))); EXPECT_TRUE(matches(VarDeclCode,
EXPECT_TRUE( traverse(TK_IgnoreImplicitCastsAndParentheses, Matcher)));
matches(VarDeclCode,
traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
Matcher)));
auto ParentMatcher = floatLiteral(hasParent(varDecl(hasName("i")))); auto ParentMatcher = floatLiteral(hasParent(varDecl(hasName("i"))));
EXPECT_TRUE(notMatches(VarDeclCode, EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, ParentMatcher)));
traverse(ast_type_traits::TK_AsIs, ParentMatcher)));
EXPECT_TRUE(matches(VarDeclCode, EXPECT_TRUE(matches(VarDeclCode,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource, ParentMatcher)));
ParentMatcher)));
EXPECT_TRUE(
matches(VarDeclCode, decl(traverse(ast_type_traits::TK_AsIs,
anyOf(cxxRecordDecl(), varDecl())))));
EXPECT_TRUE(matches(VarDeclCode,
floatLiteral(traverse(ast_type_traits::TK_AsIs,
hasParent(implicitCastExpr())))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
VarDeclCode, VarDeclCode, decl(traverse(TK_AsIs, anyOf(cxxRecordDecl(), varDecl())))));
floatLiteral(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
hasParent(varDecl())))));
EXPECT_TRUE( EXPECT_TRUE(
matches(VarDeclCode, matches(VarDeclCode,
varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, floatLiteral(traverse(TK_AsIs, hasParent(implicitCastExpr())))));
unless(parmVarDecl())))));
EXPECT_TRUE(notMatches(
VarDeclCode,
varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
has(implicitCastExpr())))));
EXPECT_TRUE(matches(VarDeclCode, varDecl(traverse(ast_type_traits::TK_AsIs,
has(implicitCastExpr())))));
EXPECT_TRUE(matches(
VarDeclCode,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
// The has() below strips away the ImplicitCastExpr before the
// traverse(AsIs) gets to process it.
varDecl(has(traverse(ast_type_traits::TK_AsIs, floatLiteral()))))));
EXPECT_TRUE(matches(
VarDeclCode,
functionDecl(traverse(ast_type_traits::TK_AsIs, hasName("foo")))));
EXPECT_TRUE(matches(
VarDeclCode,
functionDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
hasName("foo")))));
EXPECT_TRUE( EXPECT_TRUE(
matches(VarDeclCode, functionDecl(traverse(ast_type_traits::TK_AsIs, matches(VarDeclCode, floatLiteral(traverse(TK_IgnoreUnlessSpelledInSource,
hasAnyName("foo", "bar"))))); hasParent(varDecl())))));
EXPECT_TRUE(
matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
unless(parmVarDecl())))));
EXPECT_TRUE(
notMatches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
has(implicitCastExpr())))));
EXPECT_TRUE(matches(VarDeclCode,
varDecl(traverse(TK_AsIs, has(implicitCastExpr())))));
EXPECT_TRUE(matches(
VarDeclCode, traverse(TK_IgnoreUnlessSpelledInSource,
// The has() below strips away the ImplicitCastExpr
// before the traverse(AsIs) gets to process it.
varDecl(has(traverse(TK_AsIs, floatLiteral()))))));
EXPECT_TRUE(
matches(VarDeclCode, functionDecl(traverse(TK_AsIs, hasName("foo")))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
VarDeclCode, VarDeclCode,
functionDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, functionDecl(traverse(TK_IgnoreUnlessSpelledInSource, hasName("foo")))));
EXPECT_TRUE(matches(
VarDeclCode, functionDecl(traverse(TK_AsIs, hasAnyName("foo", "bar")))));
EXPECT_TRUE(
matches(VarDeclCode, functionDecl(traverse(TK_IgnoreUnlessSpelledInSource,
hasAnyName("foo", "bar"))))); hasAnyName("foo", "bar")))));
const char *Code = R"cpp( const char *Code = R"cpp(
@ -1703,32 +1689,28 @@ void bar()
} }
)cpp"; )cpp";
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
callExpr(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
hasArgument(0, floatLiteral()))))); hasArgument(0, floatLiteral())))));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
callExpr(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
hasAnyArgument(floatLiteral()))))); hasAnyArgument(floatLiteral())))));
EXPECT_TRUE( EXPECT_TRUE(
matches(VarDeclCode, matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
hasType(builtinType()))))); hasType(builtinType())))));
EXPECT_TRUE(matches( EXPECT_TRUE(
VarDeclCode, matches(VarDeclCode,
functionDecl(hasName("foo"), traverse(ast_type_traits::TK_AsIs, functionDecl(hasName("foo"),
hasDescendant(floatLiteral()))))); traverse(TK_AsIs, hasDescendant(floatLiteral())))));
EXPECT_TRUE(notMatches(Code, traverse(ast_type_traits::TK_AsIs, EXPECT_TRUE(notMatches(
Code, traverse(TK_AsIs, floatLiteral(hasParent(callExpr(
callee(functionDecl(hasName("foo")))))))));
EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
floatLiteral(hasParent(callExpr(callee( floatLiteral(hasParent(callExpr(callee(
functionDecl(hasName("foo"))))))))); functionDecl(hasName("foo")))))))));
EXPECT_TRUE(
matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
floatLiteral(hasParent(callExpr(
callee(functionDecl(hasName("foo")))))))));
Code = R"cpp( Code = R"cpp(
void foo() void foo()
@ -1736,23 +1718,22 @@ void foo()
int i = (3); int i = (3);
} }
)cpp"; )cpp";
EXPECT_TRUE( EXPECT_TRUE(matches(
matches(Code, Code, traverse(TK_IgnoreUnlessSpelledInSource,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
varDecl(hasInitializer(integerLiteral(equals(3))))))); varDecl(hasInitializer(integerLiteral(equals(3)))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(3), hasParent(varDecl(hasName("i"))))))); integerLiteral(equals(3), hasParent(varDecl(hasName("i")))))));
Code = R"cpp( Code = R"cpp(
const char *SomeString{"str"}; const char *SomeString{"str"};
)cpp"; )cpp";
EXPECT_TRUE(matches(Code, traverse(ast_type_traits::TK_AsIs, EXPECT_TRUE(
stringLiteral(hasParent(implicitCastExpr( matches(Code, traverse(TK_AsIs, stringLiteral(hasParent(implicitCastExpr(
hasParent(initListExpr()))))))); hasParent(initListExpr())))))));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
stringLiteral(hasParent(initListExpr()))))); stringLiteral(hasParent(initListExpr())))));
} }
@ -1774,8 +1755,7 @@ int foo()
} }
)cpp"; )cpp";
EXPECT_TRUE(matcherTemplateWithBinding( EXPECT_TRUE(matcherTemplateWithBinding(
Code, Code, traverse(TK_AsIs,
traverse(ast_type_traits::TK_AsIs,
returnStmt(has(implicitCastExpr(has(floatLiteral()))))))); returnStmt(has(implicitCastExpr(has(floatLiteral())))))));
} }
@ -1793,12 +1773,11 @@ void foo()
} }
)cpp"; )cpp";
EXPECT_TRUE(matches( EXPECT_TRUE(
Code, matches(Code, traverse(TK_IgnoreImplicitCastsAndParentheses,
traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
callExpr(has(callExpr(traverse( callExpr(has(callExpr(traverse(
ast_type_traits::TK_AsIs, TK_AsIs, callExpr(has(implicitCastExpr(
callExpr(has(implicitCastExpr(has(floatLiteral()))))))))))); has(floatLiteral())))))))))));
} }
TEST(Traversal, traverseMatcherThroughImplicit) { TEST(Traversal, traverseMatcherThroughImplicit) {
@ -1813,8 +1792,8 @@ void constructImplicit() {
} }
)cpp"; )cpp";
auto Matcher = traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses, auto Matcher =
implicitCastExpr()); traverse(TK_IgnoreImplicitCastsAndParentheses, implicitCastExpr());
// Verfiy that it does not segfault // Verfiy that it does not segfault
EXPECT_FALSE(matches(Code, Matcher)); EXPECT_FALSE(matches(Code, Matcher));
@ -1839,9 +1818,9 @@ void foo()
// would cause the overall matcher to be incorrectly false. // would cause the overall matcher to be incorrectly false.
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, functionDecl(anyOf( Code,
hasDescendant(Matcher), functionDecl(anyOf(hasDescendant(Matcher),
traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses, traverse(TK_IgnoreImplicitCastsAndParentheses,
functionDecl(hasDescendant(Matcher))))))); functionDecl(hasDescendant(Matcher)))))));
} }
@ -1931,32 +1910,32 @@ void func14() {
)cpp"; )cpp";
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func1"))), returnStmt(forFunction(functionDecl(hasName("func1"))),
hasReturnValue(integerLiteral(equals(42))))))); hasReturnValue(integerLiteral(equals(42)))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral(equals(42), integerLiteral(equals(42),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func1"))))))))); functionDecl(hasName("func1")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func2"))), returnStmt(forFunction(functionDecl(hasName("func2"))),
hasReturnValue(cxxTemporaryObjectExpr( hasReturnValue(cxxTemporaryObjectExpr(
hasArgument(0, integerLiteral(equals(42))))))))); hasArgument(0, integerLiteral(equals(42)))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral( integerLiteral(
equals(42), equals(42),
hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt( hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func2"))))))))))); forFunction(functionDecl(hasName("func2")))))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func3"))), returnStmt(forFunction(functionDecl(hasName("func3"))),
hasReturnValue( hasReturnValue(
cxxFunctionalCastExpr(hasSourceExpression( cxxFunctionalCastExpr(hasSourceExpression(
@ -1964,76 +1943,76 @@ void func14() {
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
integerLiteral( integerLiteral(
equals(42), equals(42),
hasParent(cxxFunctionalCastExpr(hasParent(returnStmt( hasParent(cxxFunctionalCastExpr(hasParent(returnStmt(
forFunction(functionDecl(hasName("func3"))))))))))); forFunction(functionDecl(hasName("func3")))))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func4"))), returnStmt(forFunction(functionDecl(hasName("func4"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr())))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func5"))), returnStmt(forFunction(functionDecl(hasName("func5"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr())))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func6"))), returnStmt(forFunction(functionDecl(hasName("func6"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr())))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func7"))), returnStmt(forFunction(functionDecl(hasName("func7"))),
hasReturnValue(cxxTemporaryObjectExpr()))))); hasReturnValue(cxxTemporaryObjectExpr())))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func8"))), returnStmt(forFunction(functionDecl(hasName("func8"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))))); hasSourceExpression(initListExpr())))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func9"))), returnStmt(forFunction(functionDecl(hasName("func9"))),
hasReturnValue(cxxFunctionalCastExpr( hasReturnValue(cxxFunctionalCastExpr(
hasSourceExpression(initListExpr()))))))); hasSourceExpression(initListExpr())))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func10"))), returnStmt(forFunction(functionDecl(hasName("func10"))),
hasReturnValue( hasReturnValue(
declRefExpr(to(varDecl(hasName("a"))))))))); declRefExpr(to(varDecl(hasName("a")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("a"))), declRefExpr(to(varDecl(hasName("a"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func10"))))))))); functionDecl(hasName("func10")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func11"))), returnStmt(forFunction(functionDecl(hasName("func11"))),
hasReturnValue( hasReturnValue(
declRefExpr(to(varDecl(hasName("b"))))))))); declRefExpr(to(varDecl(hasName("b")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("b"))), declRefExpr(to(varDecl(hasName("b"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func11"))))))))); functionDecl(hasName("func11")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
returnStmt(forFunction(functionDecl(hasName("func12"))), returnStmt(forFunction(functionDecl(hasName("func12"))),
hasReturnValue( hasReturnValue(
declRefExpr(to(varDecl(hasName("c"))))))))); declRefExpr(to(varDecl(hasName("c")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("c"))), declRefExpr(to(varDecl(hasName("c"))),
hasParent(returnStmt(forFunction( hasParent(returnStmt(forFunction(
functionDecl(hasName("func12"))))))))); functionDecl(hasName("func12")))))))));
@ -2041,7 +2020,7 @@ void func14() {
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse( traverse(
ast_type_traits::TK_IgnoreUnlessSpelledInSource, TK_IgnoreUnlessSpelledInSource,
lambdaExpr(forFunction(functionDecl(hasName("func13"))), lambdaExpr(forFunction(functionDecl(hasName("func13"))),
has(compoundStmt(hasDescendant(varDecl(hasName("e"))))), has(compoundStmt(hasDescendant(varDecl(hasName("e"))))),
has(declRefExpr(to(varDecl(hasName("a"))))), has(declRefExpr(to(varDecl(hasName("a"))))),
@ -2050,27 +2029,27 @@ void func14() {
has(parmVarDecl(hasName("d"))))))); has(parmVarDecl(hasName("d")))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
declRefExpr(to(varDecl(hasName("a"))), declRefExpr(to(varDecl(hasName("a"))),
hasParent(lambdaExpr(forFunction( hasParent(lambdaExpr(forFunction(
functionDecl(hasName("func13"))))))))); functionDecl(hasName("func13")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, Code,
traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, traverse(TK_IgnoreUnlessSpelledInSource,
varDecl(hasName("b"), varDecl(hasName("b"),
hasInitializer(declRefExpr(to(varDecl(hasName("c"))))), hasInitializer(declRefExpr(to(varDecl(hasName("c"))))),
hasParent(lambdaExpr( hasParent(lambdaExpr(
forFunction(functionDecl(hasName("func13"))))))))); forFunction(functionDecl(hasName("func13")))))))));
EXPECT_TRUE(matches( EXPECT_TRUE(matches(
Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, Code, traverse(TK_IgnoreUnlessSpelledInSource,
lambdaExpr( lambdaExpr(
forFunction(functionDecl(hasName("func14"))), forFunction(functionDecl(hasName("func14"))),
has(templateTypeParmDecl(hasName("TemplateType"))))))); has(templateTypeParmDecl(hasName("TemplateType")))))));
EXPECT_TRUE( EXPECT_TRUE(
matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource, matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
functionDecl(hasName("func14"), functionDecl(hasName("func14"),
hasDescendant(floatLiteral()))))); hasDescendant(floatLiteral())))));
} }