This is an archive of the discontinued LLVM Phabricator instance.

Differential D10501

Qualify all types used in AST matcher macros.
ClosedPublic

Authored by alexfh on Jun 17 2015, 5:22 AM.

Details

Reviewers
klimek
djasper
Commits
rG3b6304fa1a3f: Qualify all types used in AST matcher macros.
rC239902: Qualify all types used in AST matcher macros.
rL239902: Qualify all types used in AST matcher macros.
Summary

Qualify all types used in AST matcher macros. This makes it possible to
put AST matchers in user code into a namespace other than clang::ast_matchers
and this way prevent ODR violations that could happen when a matcher with the
same name is defined in multiple translation units. Updated comments
accordingly.

Diff Detail

Event Timeline

alexfh updated this revision to Diff 27828.Jun 17 2015, 5:22 AM
alexfh retitled this revision from to Qualify all types used in AST matcher macros..
alexfh updated this object.
alexfh edited the test plan for this revision. (Show Details)
alexfh added reviewers: djasper, klimek.
alexfh added a subscriber: Unknown Object (MLST).
Herald added a subscriber: klimek. · View Herald TranscriptJun 17 2015, 5:22 AM
klimek accepted this revision.Jun 17 2015, 5:25 AM
klimek edited edge metadata.

lg

This revision is now accepted and ready to land.Jun 17 2015, 5:25 AM
djasper added inline comments.Jun 17 2015, 5:30 AM
include/clang/ASTMatchers/ASTMatchersMacros.h
23–36

I don't know whether we need to recommend using an unnamed namespace. I would think that certain projects also have a repository of their own reusable matchers.

Do the custom matchers even have to be inside ::clang::ast_matchers?

alexfh added inline comments.Jun 17 2015, 5:34 AM
include/clang/ASTMatchers/ASTMatchersMacros.h
23–36

No, they can be in any namespace now. I just wanted to emphasize that putting all user-defined matchers to clang::ast_matchers is not a good idea. I'll suggest to use user's own namespace for the matchers.

djasper accepted this revision.Jun 17 2015, 5:36 AM
djasper edited edge metadata.

LG

alexfh updated this revision to Diff 27829.Jun 17 2015, 5:42 AM
alexfh edited edge metadata.

Updated usage instructions.

alexfh updated this revision to Diff 27830.Jun 17 2015, 5:46 AM

clang-format with LLVM style.

alexfh closed this revision.Jun 17 2015, 5:53 AM

Revision Contents

PathSize
include/
clang/
ASTMatchers/
185 lines

Diff 27830

include/clang/ASTMatchers/ASTMatchersMacros.h

Show All 14 Lines
// //
// Note that when you define a matcher with an AST_MATCHER* macro, only the // Note that when you define a matcher with an AST_MATCHER* macro, only the
// function which creates the matcher goes into the current namespace - the // function which creates the matcher goes into the current namespace - the
// class that implements the actual matcher, which gets returned by the // class that implements the actual matcher, which gets returned by the
// generator function, is put into the 'internal' namespace. This allows us // generator function, is put into the 'internal' namespace. This allows us
// to only have the functions (which is all the user cares about) in the // to only have the functions (which is all the user cares about) in the
// 'ast_matchers' namespace and hide the boilerplate. // 'ast_matchers' namespace and hide the boilerplate.
// //
// To define a matcher in user code, always put it into the clang::ast_matchers // To define a matcher in user code, put it into your own namespace. This would
// namespace and refer to the internal types via the 'internal::': // help to prevent ODR violations in case a matcher with the same name is
// defined in multiple translation units:
//
// namespace my_matchers {
// AST_MATCHER_P(clang::MemberExpr, Member,
// clang::ast_matchers::internal::Matcher<clang::ValueDecl>,
// InnerMatcher) {
// return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
// }
// } // namespace my_matchers
//
// Alternatively, an unnamed namespace may be used:
// //
djasperUnsubmitted
Not Done
ReplyInline Actions

I don't know whether we need to recommend using an unnamed namespace. I would think that certain projects also have a repository of their own reusable matchers.

Do the custom matchers even have to be inside ::clang::ast_matchers?

djasper: I don't know whether we need to recommend using an unnamed namespace. I would think that…
alexfhAuthorUnsubmitted
Not Done
ReplyInline Actions

No, they can be in any namespace now. I just wanted to emphasize that putting all user-defined matchers to clang::ast_matchers is not a good idea. I'll suggest to use user's own namespace for the matchers.

alexfh: No, they can be in any namespace now. I just wanted to emphasize that putting all user-defined…
// namespace clang { // namespace clang {
// namespace ast_matchers { // namespace ast_matchers {
// namespace {
// AST_MATCHER_P(MemberExpr, Member, // AST_MATCHER_P(MemberExpr, Member,
// internal::Matcher<ValueDecl>, InnerMatcher) { // internal::Matcher<ValueDecl>, InnerMatcher) {
// return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder); // return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
// } // }
// } // end namespace ast_matchers // } // namespace
// } // end namespace clang // } // namespace ast_matchers
// } // namespace clang
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
#define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
/// \brief AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) { ... } /// \brief AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) { ... }
/// defines a zero parameter function named DefineMatcher() that returns a /// defines a zero parameter function named DefineMatcher() that returns a
/// ReturnType object. /// ReturnType object.
#define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) \ #define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) \
inline ReturnType DefineMatcher##_getInstance(); \ inline ReturnType DefineMatcher##_getInstance(); \
inline ReturnType DefineMatcher() { \ inline ReturnType DefineMatcher() { \
return internal::MemoizedMatcher< \ return ::clang::ast_matchers::internal::MemoizedMatcher< \
ReturnType, DefineMatcher##_getInstance>::getInstance(); \ ReturnType, DefineMatcher##_getInstance>::getInstance(); \
} \ } \
inline ReturnType DefineMatcher##_getInstance() inline ReturnType DefineMatcher##_getInstance()
/// \brief AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) { ... } /// \brief AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) {
/// ... }
/// defines a single-parameter function named DefineMatcher() that returns a /// defines a single-parameter function named DefineMatcher() that returns a
/// ReturnType object. /// ReturnType 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:
/// ///
/// Param: the parameter passed to the function; its type /// Param: the parameter passed to the function; its type
/// 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(ParamType const &Param); \ inline ReturnType DefineMatcher(ParamType const &Param); \
typedef ReturnType (&DefineMatcher##_Type##OverloadId)(ParamType const &); \ typedef ReturnType(&DefineMatcher##_Type##OverloadId)(ParamType const &); \
inline ReturnType DefineMatcher(ParamType const &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.
/// Finder: an ASTMatchFinder*. /// Finder: an ASTMatchFinder*.
/// Builder: a BoundNodesTreeBuilder*. /// Builder: a BoundNodesTreeBuilder*.
/// ///
/// The code should return true if 'Node' matches. /// The code should return true if 'Node' matches.
#define AST_MATCHER(Type, DefineMatcher) \ #define AST_MATCHER(Type, DefineMatcher) \
namespace internal { \ namespace internal { \
class matcher_##DefineMatcher##Matcher : public MatcherInterface<Type> { \ class matcher_##DefineMatcher##Matcher \
: public ::clang::ast_matchers::internal::MatcherInterface<Type> { \
public: \ public: \
explicit matcher_##DefineMatcher##Matcher() {} \ explicit matcher_##DefineMatcher##Matcher() {} \
bool matches(const Type &Node, ASTMatchFinder *Finder, \ bool matches(const Type &Node, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
}; \ }; \
} \ } \
inline internal::Matcher<Type> DefineMatcher() { \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher() { \
return internal::makeMatcher( \ return ::clang::ast_matchers::internal::makeMatcher( \
new internal::matcher_##DefineMatcher##Matcher()); \ new internal::matcher_##DefineMatcher##Matcher()); \
} \ } \
inline bool internal::matcher_##DefineMatcher##Matcher::matches( \ inline bool internal::matcher_##DefineMatcher##Matcher::matches( \
const Type &Node, ASTMatchFinder *Finder, \ const Type &Node, \
BoundNodesTreeBuilder *Builder) const ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
/// \brief AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... } /// \brief AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... }
/// defines a single-parameter function named DefineMatcher() that returns a /// defines a single-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.
/// Param: the parameter passed to the function; its type /// Param: the parameter passed to the function; its type
/// is ParamType. /// is ParamType.
/// Finder: an ASTMatchFinder*. /// Finder: an ASTMatchFinder*.
/// Builder: a BoundNodesTreeBuilder*. /// Builder: a BoundNodesTreeBuilder*.
/// ///
/// The code should return true if 'Node' matches. /// The code should return true if 'Node' matches.
#define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) \ #define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) \
AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, 0) AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, 0)
#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 ::clang::ast_matchers::internal::MatcherInterface<Type> { \
public: \ public: \
explicit matcher_##DefineMatcher##OverloadId##Matcher( \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \
ParamType const &A##Param) \ ParamType const &A##Param) \
: Param(A##Param) {} \ : Param(A##Param) {} \
bool matches(const Type &Node, ASTMatchFinder *Finder, \ bool matches(const Type &Node, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
\ \
private: \ private: \
ParamType const Param; \ ParamType const Param; \
}; \ }; \
} \ } \
inline internal::Matcher<Type> DefineMatcher(ParamType const &Param) { \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
return internal::makeMatcher( \ ParamType const &Param) { \
return ::clang::ast_matchers::internal::makeMatcher( \
new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \ new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \
} \ } \
typedef internal::Matcher<Type>(&DefineMatcher##_Type##OverloadId)( \ typedef ::clang::ast_matchers::internal::Matcher<Type>( \
ParamType const &Param); \ &DefineMatcher##_Type##OverloadId)(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, \
BoundNodesTreeBuilder *Builder) const ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::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.
/// ///
/// 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.
/// Param1, Param2: the parameters passed to the function; their types /// Param1, Param2: the parameters passed to the function; their types
/// are ParamType1 and ParamType2. /// are ParamType1 and ParamType2.
/// Finder: an ASTMatchFinder*. /// Finder: an ASTMatchFinder*.
/// Builder: a BoundNodesTreeBuilder*. /// Builder: a BoundNodesTreeBuilder*.
/// ///
/// The code should return true if 'Node' matches. /// The code should return true if 'Node' matches.
#define AST_MATCHER_P2(Type, DefineMatcher, ParamType1, Param1, ParamType2, \ #define AST_MATCHER_P2(Type, DefineMatcher, ParamType1, Param1, ParamType2, \
Param2) \ Param2) \
AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, ParamType2, \ 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 ::clang::ast_matchers::internal::MatcherInterface<Type> { \
public: \ public: \
matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
ParamType2 const &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, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
\ \
private: \ private: \
ParamType1 const Param1; \ ParamType1 const Param1; \
ParamType2 const Param2; \ ParamType2 const Param2; \
}; \ }; \
} \ } \
inline internal::Matcher<Type> DefineMatcher(ParamType1 const &Param1, \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
ParamType2 const &Param2) { \ ParamType1 const &Param1, ParamType2 const &Param2) { \
return internal::makeMatcher( \ return ::clang::ast_matchers::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 ::clang::ast_matchers::internal::Matcher<Type>( \
ParamType1 const &Param1, ParamType2 const &Param2); \ &DefineMatcher##_Type##OverloadId)(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, \
BoundNodesTreeBuilder *Builder) const ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::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
/// will look at that as two arguments. However, you can pass /// will look at that as two arguments. However, you can pass
/// \c void(TypeList<Foo, Bar>), which works thanks to the parenthesis. /// \c void(TypeList<Foo, Bar>), which works thanks to the parenthesis.
/// The \c PolymorphicMatcherWithParam* classes will unpack the function type to /// The \c PolymorphicMatcherWithParam* classes will unpack the function type to
/// extract the TypeList object. /// extract the TypeList object.
#define AST_POLYMORPHIC_SUPPORTED_TYPES(...) \ #define AST_POLYMORPHIC_SUPPORTED_TYPES(...) \
void(internal::TypeList<__VA_ARGS__>) void(::clang::ast_matchers::internal::TypeList<__VA_ARGS__>)
/// \brief AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... } /// \brief AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... }
/// defines a single-parameter function named DefineMatcher() that is /// defines a single-parameter function named DefineMatcher() that is
/// polymorphic in the return type. /// polymorphic in the return type.
/// ///
/// The variables are the same as for AST_MATCHER, but NodeType will be deduced /// The variables are the same as for AST_MATCHER, but NodeType will be deduced
/// from the calling context. /// from the calling context.
#define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF) \ #define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF) \
namespace internal { \ namespace internal { \
template <typename NodeType> \ template <typename NodeType> \
class matcher_##DefineMatcher##Matcher : public MatcherInterface<NodeType> { \ class matcher_##DefineMatcher##Matcher \
: public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
public: \ public: \
bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ bool matches(const NodeType &Node, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
}; \ }; \
} \ } \
inline internal::PolymorphicMatcherWithParam0< \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \
internal::matcher_##DefineMatcher##Matcher, ReturnTypesF> \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF> \
DefineMatcher() { \ DefineMatcher() { \
return internal::PolymorphicMatcherWithParam0< \ return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \
internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>(); \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>(); \
} \ } \
template <typename NodeType> \ template <typename NodeType> \
bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches( \ bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches( \
const NodeType &Node, ASTMatchFinder *Finder, \ const NodeType &Node, \
BoundNodesTreeBuilder *Builder) const ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
/// \brief AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... } /// \brief AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... }
/// defines a single-parameter function named DefineMatcher() that is /// defines a single-parameter function named DefineMatcher() that is
/// polymorphic in the return type. /// polymorphic in the return type.
/// ///
/// The variables are the same as for /// The variables are the same as for
/// AST_MATCHER_P, with the addition of NodeType, which specifies the node type /// AST_MATCHER_P, with the addition of NodeType, which specifies the node type
/// of the matcher Matcher<NodeType> returned by the function matcher(). /// of the matcher Matcher<NodeType> returned by the function matcher().
/// ///
/// FIXME: Pull out common code with above macro? /// FIXME: Pull out common code with above macro?
#define AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ReturnTypesF, ParamType, \ #define AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ReturnTypesF, ParamType, \
Param) \ Param) \
AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType, \ AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType, \
Param, 0) Param, 0)
#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 ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
public: \ public: \
explicit matcher_##DefineMatcher##OverloadId##Matcher( \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \
ParamType const &A##Param) \ ParamType const &A##Param) \
: Param(A##Param) {} \ : Param(A##Param) {} \
bool matches(const NodeType &Node, ASTMatchFinder *Finder, \ bool matches(const NodeType &Node, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
\ \
private: \ private: \
ParamType const Param; \ ParamType const Param; \
}; \ }; \
} \ } \
inline internal::PolymorphicMatcherWithParam1< \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF> DefineMatcher(ParamType const &Param) { \ ReturnTypesF> \
return internal::PolymorphicMatcherWithParam1< \ DefineMatcher(ParamType const &Param) { \
return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF>(Param); \ ReturnTypesF>(Param); \
} \ } \
typedef internal::PolymorphicMatcherWithParam1< \ typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \
ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \
ParamType const &Param); \ ParamType const &Param); \
template <typename NodeType, typename ParamT> \ template <typename NodeType, typename ParamT> \
bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ bool internal:: \
NodeType, ParamT>::matches(const NodeType &Node, ASTMatchFinder *Finder, \ matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \
BoundNodesTreeBuilder *Builder) const const NodeType &Node, \
::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::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
/// the return type. /// the return type.
/// ///
/// The variables are the same as for AST_MATCHER_P2, with the /// The variables are the same as for AST_MATCHER_P2, with the
/// addition of NodeType, which specifies the node type of the matcher /// addition of NodeType, which specifies the node type of the matcher
/// Matcher<NodeType> returned by the function DefineMatcher(). /// Matcher<NodeType> returned by the function DefineMatcher().
#define AST_POLYMORPHIC_MATCHER_P2(DefineMatcher, ReturnTypesF, ParamType1, \ #define AST_POLYMORPHIC_MATCHER_P2(DefineMatcher, ReturnTypesF, ParamType1, \
Param1, ParamType2, Param2) \ Param1, ParamType2, Param2) \
AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType1, \ AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType1, \
Param1, ParamType2, Param2, 0) Param1, ParamType2, Param2, 0)
#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 ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
public: \ public: \
matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
ParamType2 const &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, \
BoundNodesTreeBuilder *Builder) const override; \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::BoundNodesTreeBuilder \
*Builder) const override; \
\ \
private: \ private: \
ParamType1 const Param1; \ ParamType1 const Param1; \
ParamType2 const Param2; \ ParamType2 const Param2; \
}; \ }; \
} \ } \
inline internal::PolymorphicMatcherWithParam2< \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \
ParamType2, ReturnTypesF> DefineMatcher(ParamType1 const &Param1, \ ParamType2, ReturnTypesF> \
ParamType2 const &Param2) { \ DefineMatcher(ParamType1 const &Param1, ParamType2 const &Param2) { \
return internal::PolymorphicMatcherWithParam2< \ return ::clang::ast_matchers::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 ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \
internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \
ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \ ParamType2, ReturnTypesF>(&DefineMatcher##_Type##OverloadId)( \
ParamType1 const &Param1, ParamType2 const &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>:: \
const NodeType &Node, ASTMatchFinder *Finder, \ matches(const NodeType &Node, \
BoundNodesTreeBuilder *Builder) const ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
::clang::ast_matchers::internal::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.
#define AST_TYPE_MATCHER(NodeType, MatcherName) \ #define AST_TYPE_MATCHER(NodeType, MatcherName) \
const internal::VariadicDynCastAllOfMatcher<Type, NodeType> MatcherName const ::clang::ast_matchers::internal::VariadicDynCastAllOfMatcher< \
Type, NodeType> MatcherName
// FIXME: add a matcher for TypeLoc derived classes using its custom casting // FIXME: add a matcher for TypeLoc derived classes using its custom casting
// API (no longer dyn_cast) if/when we need such matching // API (no longer dyn_cast) if/when we need such matching
/// \brief AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName) defines /// \brief AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName) defines
/// the matcher \c MatcherName that can be used to traverse from one \c Type /// the matcher \c MatcherName that can be used to traverse from one \c Type
/// to another. /// to another.
/// ///
/// For a specific \c SpecificType, the traversal is done using /// For a specific \c SpecificType, the traversal is done using
/// \c SpecificType::FunctionName. The existence of such a function determines /// \c SpecificType::FunctionName. The existence of such a function determines
/// whether a corresponding matcher can be used on \c SpecificType. /// whether a corresponding matcher can be used on \c SpecificType.
#define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \ #define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \
namespace internal { \ namespace internal { \
template <typename T> struct TypeMatcher##MatcherName##Getter { \ template <typename T> struct TypeMatcher##MatcherName##Getter { \
static QualType (T::*value())() const { return &T::FunctionName; } \ static QualType (T::*value())() const { return &T::FunctionName; } \
}; \ }; \
} \ } \
const internal::TypeTraversePolymorphicMatcher< \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
QualType, internal::TypeMatcher##MatcherName##Getter, \ QualType, \
internal::TypeTraverseMatcher, ReturnTypesF>::Func MatcherName ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \
::clang::ast_matchers::internal::TypeTraverseMatcher, \
ReturnTypesF>::Func MatcherName
/// \brief AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName) works /// \brief AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName) works
/// identical to \c AST_TYPE_TRAVERSE_MATCHER but operates on \c TypeLocs. /// identical to \c AST_TYPE_TRAVERSE_MATCHER but operates on \c TypeLocs.
#define AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \ #define AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \
namespace internal { \ namespace internal { \
template <typename T> struct TypeLocMatcher##MatcherName##Getter { \ template <typename T> struct TypeLocMatcher##MatcherName##Getter { \
static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \ static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \
}; \ }; \
} \ } \
const internal::TypeTraversePolymorphicMatcher< \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
TypeLoc, internal::TypeLocMatcher##MatcherName##Getter, \ TypeLoc, \
internal::TypeLocTraverseMatcher, ReturnTypesF>::Func MatcherName##Loc; \ ::clang::ast_matchers::internal::TypeLocMatcher##MatcherName##Getter, \
::clang::ast_matchers::internal::TypeLocTraverseMatcher, \
ReturnTypesF>::Func MatcherName##Loc; \
AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName##Type, ReturnTypesF) AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName##Type, ReturnTypesF)
#endif #endif