This is an archive of the discontinued LLVM Phabricator instance.

Differential D3994

Fix equalsNode() to accept pointers to derived types.
ClosedPublic

Authored by sbenza on Jun 2 2014, 2:06 PM.

Details

Reviewers
klimek
Commits
rG93d68595a996: Fix equalsNode() to accept pointers to derived types.
rC210269: Fix equalsNode() to accept pointers to derived types.
rL210269: Fix equalsNode() to accept pointers to derived types.
Summary

Move the 'const' in the AST_*MATCHER_P* macros to the right of ParamType to
avoiad applying the constness on the wrong level when ParamType is a pointer.
Change equalsNode() to explicitly accept 'const Decl*' or 'const Stmt*'.

Diff Detail

Event Timeline

sbenza updated this revision to Diff 10026.Jun 2 2014, 2:06 PM
sbenza retitled this revision from to Fix equalsNode() to accept pointers to derived types..
sbenza updated this object.
sbenza edited the test plan for this revision. (Show Details)
sbenza added a reviewer: klimek.
sbenza added a subscriber: Unknown Object (MLST).
Herald added a subscriber: klimek. · View Herald TranscriptJun 2 2014, 2:06 PM
klimek edited edge metadata.Jun 3 2014, 1:11 AM

Are you sure you're synced to the latest version?
http://reviews.llvm.org/rL209652

If your solution works, I like it more (I tried, but didn't get it to compile :P), but it needs to be based on head ;)

sbenza added a comment.Jun 3 2014, 6:30 AM

After months of being annoyed by it, I decide to fix it a few days after you already submitted the fix.
I'll sync and fixup the change.

sbenza updated this revision to Diff 10139.Jun 5 2014, 6:48 AM
sbenza edited edge metadata.

Sync'd to head and replaced the recently added fix.

sbenza added a comment.Jun 5 2014, 6:49 AM

Sync'd and merged. I kept the your test changes.

klimek accepted this revision.Jun 5 2014, 6:50 AM
klimek edited edge metadata.

lg

This revision is now accepted and ready to land.Jun 5 2014, 6:50 AM
sbenza closed this revision.Jun 5 2014, 7:55 AM
sbenza updated this revision to Diff 10142.

Closed by commit rL210269 (authored by @sbenza).

Revision Contents

PathSize
include/
clang/
ASTMatchers/
8 lines
14 lines
50 lines

Diff 10139

include/clang/ASTMatchers/ASTMatchers.h

Show First 20 Lines • Show All 3,498 Lines • ▼ Show 20 Lines
/// \brief Overloads for the \c equalsNode matcher. /// \brief Overloads for the \c equalsNode matcher.
/// FIXME: Implement for other node types. /// FIXME: Implement for other node types.
/// @{ /// @{
/// \brief Matches if a node equals another node. /// \brief Matches if a node equals another node.
/// ///
/// \c Decl has pointer identity in the AST. /// \c Decl has pointer identity in the AST.
inline internal::Matcher<Decl> equalsNode(const Decl *Node) { AST_MATCHER_P_OVERLOAD(Decl, equalsNode, const Decl*, Other, 0) {
return internal::makeMatcher(new internal::EqualsNodeMatcher<Decl>(Node)); return &Node == Other;
} }
/// \brief Matches if a node equals another node. /// \brief Matches if a node equals another node.
/// ///
/// \c Stmt has pointer identity in the AST. /// \c Stmt has pointer identity in the AST.
/// ///
inline internal::Matcher<Stmt> equalsNode(const Stmt *Node) { AST_MATCHER_P_OVERLOAD(Stmt, equalsNode, const Stmt*, Other, 1) {
return internal::makeMatcher(new internal::EqualsNodeMatcher<Stmt>(Node)); return &Node == Other;
} }
/// @} /// @}
/// \brief Matches each case or default statement belonging to the given switch /// \brief Matches each case or default statement belonging to the given switch
/// statement. This matcher may produce multiple matches. /// statement. This matcher may produce multiple matches.
/// ///
/// Given /// Given
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

include/clang/ASTMatchers/ASTMatchersInternal.h

Show First 20 Lines • Show All 1,381 Lines • ▼ Show 20 Linespublic:
bool matchesNode(const T &Node) const override { bool matchesNode(const T &Node) const override {
return Node.getValue() == ExpectedValue; return Node.getValue() == ExpectedValue;
} }
private: private:
const ValueT ExpectedValue; const ValueT ExpectedValue;
}; };
template <typename T>
class EqualsNodeMatcher : public SingleNodeMatcherInterface<T> {
public:
explicit EqualsNodeMatcher(const T *ExpectedNode)
: ExpectedNode(ExpectedNode) {}
bool matchesNode(const T &Node) const override {
return &Node == ExpectedNode;
}
private:
const T *ExpectedNode;
};
/// \brief A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a /// \brief A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a
/// variadic functor that takes a number of Matcher<TargetT> and returns a /// variadic functor that takes a number of Matcher<TargetT> and returns a
/// Matcher<SourceT> that matches TargetT nodes that are matched by all of the /// Matcher<SourceT> that matches TargetT nodes that are matched by all of the
/// given matchers, if SourceT can be dynamically casted into TargetT. /// given matchers, if SourceT can be dynamically casted into TargetT.
/// ///
/// For example: /// For example:
/// const VariadicDynCastAllOfMatcher< /// const VariadicDynCastAllOfMatcher<
/// Decl, CXXRecordDecl> record; /// Decl, CXXRecordDecl> record;
▲ Show 20 Lines • Show All 194 Lines • Show Last 20 Lines

include/clang/ASTMatchers/ASTMatchersMacros.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
/// is ParamType. /// is ParamType.
/// ///
/// The code should return an instance of ReturnType. /// The code should return an instance of ReturnType.
#define AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) \ #define AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) \
AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, Param, \ AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, Param, \
0) 0)
#define AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, \ #define AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, \
Param, OverloadId) \ Param, OverloadId) \
inline ReturnType DefineMatcher(const ParamType &Param); \ inline ReturnType DefineMatcher(ParamType const &Param); \
typedef ReturnType (&DefineMatcher##_Type##OverloadId)(const ParamType &); \ typedef ReturnType (&DefineMatcher##_Type##OverloadId)(ParamType const &); \
inline ReturnType DefineMatcher(const ParamType &Param) inline ReturnType DefineMatcher(ParamType const &Param)
/// \brief AST_MATCHER(Type, DefineMatcher) { ... } /// \brief AST_MATCHER(Type, DefineMatcher) { ... }
/// defines a zero parameter function named DefineMatcher() that returns a /// defines a zero parameter function named DefineMatcher() that returns a
/// Matcher<Type> object. /// Matcher<Type> object.
/// ///
/// The code between the curly braces has access to the following variables: /// The code between the curly braces has access to the following variables:
/// ///
/// Node: the AST node being matched; its type is Type. /// Node: the AST node being matched; its type is Type.
Show All 36 Lines
#define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, \ #define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, \
OverloadId) \ OverloadId) \
namespace internal { \ namespace internal { \
class matcher_##DefineMatcher##OverloadId##Matcher \ class matcher_##DefineMatcher##OverloadId##Matcher \
: public MatcherInterface<Type> { \ : public MatcherInterface<Type> { \
public: \ public: \
explicit matcher_##DefineMatcher##OverloadId##Matcher( \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \
const ParamType &A##Param) \ ParamType const &A##Param) \
: Param(A##Param) {} \ : Param(A##Param) {} \
bool matches(const Type &Node, ASTMatchFinder *Finder, \ bool matches(const Type &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const override; \ BoundNodesTreeBuilder *Builder) const override; \
\ \
private: \ private: \
const ParamType Param; \ ParamType const Param; \
}; \ }; \
} \ } \
inline internal::Matcher<Type> DefineMatcher(const ParamType &Param) { \ inline internal::Matcher<Type> DefineMatcher(ParamType const &Param) { \
return internal::makeMatcher( \ return internal::makeMatcher( \
new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \ new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \
} \ } \
typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \ typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \
const ParamType &Param); \ ParamType const &Param); \
inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \
const Type &Node, ASTMatchFinder *Finder, \ const Type &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const BoundNodesTreeBuilder *Builder) const
/// \brief AST_MATCHER_P2( /// \brief AST_MATCHER_P2(
/// Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } /// Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... }
/// defines a two-parameter function named DefineMatcher() that returns a /// defines a two-parameter function named DefineMatcher() that returns a
/// Matcher<Type> object. /// Matcher<Type> object.
Show All 13 Lines AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, ParamType2, \
Param2, 0) Param2, 0)
#define AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, \ #define AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, \
ParamType2, Param2, OverloadId) \ ParamType2, Param2, OverloadId) \
namespace internal { \ namespace internal { \
class matcher_##DefineMatcher##OverloadId##Matcher \ class matcher_##DefineMatcher##OverloadId##Matcher \
: public MatcherInterface<Type> { \ : public MatcherInterface<Type> { \
public: \ public: \
matcher_##DefineMatcher##OverloadId##Matcher(const ParamType1 &A##Param1, \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
const ParamType2 &A##Param2) \ ParamType2 const &A##Param2) \
: Param1(A##Param1), Param2(A##Param2) {} \ : Param1(A##Param1), Param2(A##Param2) {} \
bool matches(const Type &Node, ASTMatchFinder *Finder, \ bool matches(const Type &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const override; \ BoundNodesTreeBuilder *Builder) const override; \
\ \
private: \ private: \
const ParamType1 Param1; \ ParamType1 const Param1; \
const ParamType2 Param2; \ ParamType2 const Param2; \
}; \ }; \
} \ } \
inline internal::Matcher<Type> DefineMatcher(const ParamType1 &Param1, \ inline internal::Matcher<Type> DefineMatcher(ParamType1 const &Param1, \
const ParamType2 &Param2) { \ ParamType2 const &Param2) { \
return internal::makeMatcher( \ return internal::makeMatcher( \
new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param1, \ new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param1, \
Param2)); \ Param2)); \
} \ } \
typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \ typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \
const ParamType1 &Param1, const ParamType2 &Param2); \ ParamType1 const &Param1, ParamType2 const &Param2); \
inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \
const Type &Node, ASTMatchFinder *Finder, \ const Type &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const BoundNodesTreeBuilder *Builder) const
/// \brief Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER* /// \brief Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER*
/// macros. /// macros.
/// ///
/// You can't pass something like \c TypeList<Foo, Bar> to a macro, because it /// You can't pass something like \c TypeList<Foo, Bar> to a macro, because it
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#define AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, \ #define AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, \
ParamType, Param, OverloadId) \ ParamType, Param, OverloadId) \
namespace internal { \ namespace internal { \
template <typename NodeType, typename ParamT> \ template <typename NodeType, typename ParamT> \
class matcher_##DefineMatcher##OverloadId##Matcher \ class matcher_##DefineMatcher##OverloadId##Matcher \
: public MatcherInterface<NodeType> { \ : public MatcherInterface<NodeType> { \
public: \ public: \
explicit matcher_##DefineMatcher##OverloadId##Matcher( \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \
const ParamType &A##Param) \ ParamType const &A##Param) \
: Param(A##Param) {} \ : Param(A##Param) {} \
bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ bool matches(const NodeType &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const override; \ BoundNodesTreeBuilder *Builder) const override; \
\ \
private: \ private: \
const ParamType Param; \ ParamType const Param; \
}; \ }; \
} \ } \
inline internal::PolymorphicMatcherWithParam1< \ inline internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF> DefineMatcher(const ParamType &Param) { \ ReturnTypesF> DefineMatcher(ParamType const &Param) { \
return internal::PolymorphicMatcherWithParam1< \ return internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF>(Param); \ ReturnTypesF>(Param); \
} \ } \
typedef internal::PolymorphicMatcherWithParam1< \ typedef internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \
const ParamType &Param); \ ParamType const &Param); \
template <typename NodeType, typename ParamT> \ template <typename NodeType, typename ParamT> \
bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \
NodeType, ParamT>::matches(const NodeType &Node, ASTMatchFinder *Finder, \ NodeType, ParamT>::matches(const NodeType &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const BoundNodesTreeBuilder *Builder) const
/// \brief AST_POLYMORPHIC_MATCHER_P2( /// \brief AST_POLYMORPHIC_MATCHER_P2(
/// DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } /// DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... }
/// defines a two-parameter function named matcher() that is polymorphic in /// defines a two-parameter function named matcher() that is polymorphic in
Show All 10 Lines
#define AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, \ #define AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, \
ParamType1, Param1, ParamType2, \ ParamType1, Param1, ParamType2, \
Param2, OverloadId) \ Param2, OverloadId) \
namespace internal { \ namespace internal { \
template <typename NodeType, typename ParamT1, typename ParamT2> \ template <typename NodeType, typename ParamT1, typename ParamT2> \
class matcher_##DefineMatcher##OverloadId##Matcher \ class matcher_##DefineMatcher##OverloadId##Matcher \
: public MatcherInterface<NodeType> { \ : public MatcherInterface<NodeType> { \
public: \ public: \
matcher_##DefineMatcher##OverloadId##Matcher(const ParamType1 &A##Param1, \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
const ParamType2 &A##Param2) \ ParamType2 const &A##Param2) \
: Param1(A##Param1), Param2(A##Param2) {} \ : Param1(A##Param1), Param2(A##Param2) {} \
bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ bool matches(const NodeType &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const override; \ BoundNodesTreeBuilder *Builder) const override; \
\ \
private: \ private: \
const ParamType1 Param1; \ ParamType1 const Param1; \
const ParamType2 Param2; \ ParamType2 const Param2; \
}; \ }; \
} \ } \
inline internal::PolymorphicMatcherWithParam2< \ inline internal::PolymorphicMatcherWithParam2< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \
ParamType2, ReturnTypesF> DefineMatcher(const ParamType1 &Param1, \ ParamType2, ReturnTypesF> DefineMatcher(ParamType1 const &Param1, \
const ParamType2 &Param2) { \ ParamType2 const &Param2) { \
return internal::PolymorphicMatcherWithParam2< \ return internal::PolymorphicMatcherWithParam2< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \
ParamType2, ReturnTypesF>(Param1, Param2); \ ParamType2, ReturnTypesF>(Param1, Param2); \
} \ } \
typedef internal::PolymorphicMatcherWithParam2< \ typedef internal::PolymorphicMatcherWithParam2< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \
ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \
const ParamType1 &Param1, const ParamType2 &Param2); \ ParamType1 const &Param1, ParamType2 const &Param2); \
template <typename NodeType, typename ParamT1, typename ParamT2> \ template <typename NodeType, typename ParamT1, typename ParamT2> \
bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \
NodeType, ParamT1, ParamT2>::matches( \ NodeType, ParamT1, ParamT2>::matches( \
const NodeType &Node, ASTMatchFinder *Finder, \ const NodeType &Node, ASTMatchFinder *Finder, \
BoundNodesTreeBuilder *Builder) const BoundNodesTreeBuilder *Builder) const
/// \brief Creates a variadic matcher for both a specific \c Type as well as /// \brief Creates a variadic matcher for both a specific \c Type as well as
/// the corresponding \c TypeLoc. /// the corresponding \c TypeLoc.
Show All 36 Lines