003 File Manager
Current Path:
/usr/src/contrib/llvm-project/clang/include/clang/ASTMatchers
usr
/
src
/
contrib
/
llvm-project
/
clang
/
include
/
clang
/
ASTMatchers
/
📁
..
📄
ASTMatchFinder.h
(11.55 KB)
📄
ASTMatchers.h
(214.24 KB)
📄
ASTMatchersInternal.h
(69.97 KB)
📄
ASTMatchersMacros.h
(36.19 KB)
📁
Dynamic
📄
GtestMatchers.h
(1.32 KB)
Editing: ASTMatchersMacros.h
//===--- ASTMatchersMacros.h - Structural query framework -------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// // // Defines macros that enable us to define new matchers in a single place. // Since a matcher is a function which returns a Matcher<T> object, where // T is the type of the actual implementation of the matcher, the macros allow // us to write matchers like functions and take care of the definition of the // class boilerplate. // // 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 // class that implements the actual matcher, which gets returned by the // 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 // 'ast_matchers' namespace and hide the boilerplate. // // To define a matcher in user code, put it into your own namespace. This would // 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: // // namespace clang { // namespace ast_matchers { // namespace { // AST_MATCHER_P(MemberExpr, Member, // internal::Matcher<ValueDecl>, InnerMatcher) { // return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder); // } // } // namespace // } // namespace ast_matchers // } // namespace clang // //===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H /// AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) { ... } /// defines a zero parameter function named DefineMatcher() that returns a /// ReturnType object. #define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) \ inline ReturnType DefineMatcher##_getInstance(); \ inline ReturnType DefineMatcher() { \ return ::clang::ast_matchers::internal::MemoizedMatcher< \ ReturnType, DefineMatcher##_getInstance>::getInstance(); \ } \ inline ReturnType DefineMatcher##_getInstance() /// AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) { /// ... } /// defines a single-parameter function named DefineMatcher() that returns a /// ReturnType object. /// /// The code between the curly braces has access to the following variables: /// /// Param: the parameter passed to the function; its type /// is ParamType. /// /// The code should return an instance of ReturnType. #define AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) \ AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, Param, \ 0) #define AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, \ Param, OverloadId) \ inline ReturnType DefineMatcher(ParamType const &Param); \ typedef ReturnType (&DefineMatcher##_Type##OverloadId)(ParamType const &); \ inline ReturnType DefineMatcher(ParamType const &Param) /// AST_MATCHER(Type, DefineMatcher) { ... } /// defines a zero parameter function named DefineMatcher() that returns a /// Matcher<Type> object. /// /// The code between the curly braces has access to the following variables: /// /// Node: the AST node being matched; its type is Type. /// Finder: an ASTMatchFinder*. /// Builder: a BoundNodesTreeBuilder*. /// /// The code should return true if 'Node' matches. #define AST_MATCHER(Type, DefineMatcher) \ namespace internal { \ class matcher_##DefineMatcher##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ explicit matcher_##DefineMatcher##Matcher() = default; \ bool matches(const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ }; \ } \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher() { \ return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##Matcher()); \ } \ inline bool internal::matcher_##DefineMatcher##Matcher::matches( \ const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... } /// defines a single-parameter function named DefineMatcher() that returns a /// Matcher<Type> object. /// /// The code between the curly braces has access to the following variables: /// /// Node: the AST node being matched; its type is Type. /// Param: the parameter passed to the function; its type /// is ParamType. /// Finder: an ASTMatchFinder*. /// Builder: a BoundNodesTreeBuilder*. /// /// The code should return true if 'Node' matches. #define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) \ AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, 0) #define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, \ OverloadId) \ namespace internal { \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher(ParamType A##Param) \ : Param(std::move(A##Param)) {} \ bool matches(const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ ParamType const Param; \ }; \ } \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ ParamType Param) { \ return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##OverloadId##Matcher( \ std::move(Param))); \ } \ typedef ::clang::ast_matchers::internal::Matcher<Type> ( \ &DefineMatcher##_Type##OverloadId)(ParamType Param); \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// AST_MATCHER_P2( /// Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } /// defines a two-parameter function named DefineMatcher() that returns a /// Matcher<Type> object. /// /// The code between the curly braces has access to the following variables: /// /// Node: the AST node being matched; its type is Type. /// Param1, Param2: the parameters passed to the function; their types /// are ParamType1 and ParamType2. /// Finder: an ASTMatchFinder*. /// Builder: a BoundNodesTreeBuilder*. /// /// The code should return true if 'Node' matches. #define AST_MATCHER_P2(Type, DefineMatcher, ParamType1, Param1, ParamType2, \ Param2) \ AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, ParamType2, \ Param2, 0) #define AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, \ ParamType2, Param2, OverloadId) \ namespace internal { \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 A##Param1, \ ParamType2 A##Param2) \ : Param1(std::move(A##Param1)), Param2(std::move(A##Param2)) {} \ bool matches(const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ ParamType1 const Param1; \ ParamType2 const Param2; \ }; \ } \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ ParamType1 Param1, ParamType2 Param2) { \ return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##OverloadId##Matcher( \ std::move(Param1), std::move(Param2))); \ } \ typedef ::clang::ast_matchers::internal::Matcher<Type> ( \ &DefineMatcher##_Type##OverloadId)(ParamType1 Param1, \ ParamType2 Param2); \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER* /// macros. /// /// 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 /// \c void(TypeList<Foo, Bar>), which works thanks to the parenthesis. /// The \c PolymorphicMatcherWithParam* classes will unpack the function type to /// extract the TypeList object. #define AST_POLYMORPHIC_SUPPORTED_TYPES(...) \ void(::clang::ast_matchers::internal::TypeList<__VA_ARGS__>) /// AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... } /// defines a single-parameter function named DefineMatcher() that is /// polymorphic in the return type. /// /// The variables are the same as for AST_MATCHER, but NodeType will be deduced /// from the calling context. #define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF) \ namespace internal { \ template <typename NodeType> \ class matcher_##DefineMatcher##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ bool matches(const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ }; \ } \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF> \ DefineMatcher() { \ return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam0< \ internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>(); \ } \ template <typename NodeType> \ bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches( \ const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... } /// defines a single-parameter function named DefineMatcher() that is /// polymorphic in the return type. /// /// The variables are the same as for /// AST_MATCHER_P, with the addition of NodeType, which specifies the node type /// of the matcher Matcher<NodeType> returned by the function matcher(). /// /// FIXME: Pull out common code with above macro? #define AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ReturnTypesF, ParamType, \ Param) \ AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType, \ Param, 0) #define AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, \ ParamType, Param, OverloadId) \ namespace internal { \ template <typename NodeType, typename ParamT> \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher(ParamType A##Param) \ : Param(std::move(A##Param)) {} \ bool matches(const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ ParamType const Param; \ }; \ } \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ ReturnTypesF> \ DefineMatcher(ParamType Param) { \ return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ ReturnTypesF>(std::move(Param)); \ } \ typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType, \ ReturnTypesF> (&DefineMatcher##_Type##OverloadId)(ParamType Param); \ template <typename NodeType, typename ParamT> \ bool internal:: \ matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \ const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \ const /// AST_POLYMORPHIC_MATCHER_P2( /// DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... } /// defines a two-parameter function named matcher() that is polymorphic in /// the return type. /// /// The variables are the same as for AST_MATCHER_P2, with the /// addition of NodeType, which specifies the node type of the matcher /// Matcher<NodeType> returned by the function DefineMatcher(). #define AST_POLYMORPHIC_MATCHER_P2(DefineMatcher, ReturnTypesF, ParamType1, \ Param1, ParamType2, Param2) \ AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType1, \ Param1, ParamType2, Param2, 0) #define AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, \ ParamType1, Param1, ParamType2, \ Param2, OverloadId) \ namespace internal { \ template <typename NodeType, typename ParamT1, typename ParamT2> \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 A##Param1, \ ParamType2 A##Param2) \ : Param1(std::move(A##Param1)), Param2(std::move(A##Param2)) {} \ bool matches(const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ ParamType1 const Param1; \ ParamType2 const Param2; \ }; \ } \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ ParamType2, ReturnTypesF> \ DefineMatcher(ParamType1 Param1, ParamType2 Param2) { \ return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ ParamType2, ReturnTypesF>(std::move(Param1), std::move(Param2)); \ } \ typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam2< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, ParamType1, \ ParamType2, ReturnTypesF> (&DefineMatcher##_Type##OverloadId)( \ ParamType1 Param1, ParamType2 Param2); \ template <typename NodeType, typename ParamT1, typename ParamT2> \ bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \ NodeType, ParamT1, ParamT2>:: \ matches(const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \ const // FIXME: add a matcher for TypeLoc derived classes using its custom casting // API (no longer dyn_cast) if/when we need such matching #define AST_TYPE_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName, \ ReturnTypesF) \ namespace internal { \ template <typename T> struct TypeMatcher##MatcherName##Getter { \ static QualType (T::*value())() const { return &T::FunctionName; } \ }; \ } \ extern const ::clang::ast_matchers::internal:: \ TypeTraversePolymorphicMatcher< \ QualType, \ ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \ ::clang::ast_matchers::internal::TypeTraverseMatcher, \ ReturnTypesF>::Func MatcherName #define AST_TYPE_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF) \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ QualType, \ ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \ ::clang::ast_matchers::internal::TypeTraverseMatcher, \ ReturnTypesF>::Func MatcherName /// AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName) defines /// the matcher \c MatcherName that can be used to traverse from one \c Type /// to another. /// /// For a specific \c SpecificType, the traversal is done using /// \c SpecificType::FunctionName. The existence of such a function determines /// whether a corresponding matcher can be used on \c SpecificType. #define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \ namespace internal { \ template <typename T> struct TypeMatcher##MatcherName##Getter { \ static QualType (T::*value())() const { return &T::FunctionName; } \ }; \ } \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ QualType, \ ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \ ::clang::ast_matchers::internal::TypeTraverseMatcher, \ ReturnTypesF>::Func MatcherName #define AST_TYPELOC_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName, \ ReturnTypesF) \ namespace internal { \ template <typename T> struct TypeLocMatcher##MatcherName##Getter { \ static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \ }; \ } \ extern const ::clang::ast_matchers::internal:: \ TypeTraversePolymorphicMatcher< \ TypeLoc, \ ::clang::ast_matchers::internal:: \ TypeLocMatcher##MatcherName##Getter, \ ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \ ReturnTypesF>::Func MatcherName##Loc; \ AST_TYPE_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName##Type, ReturnTypesF) #define AST_TYPELOC_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF) \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ TypeLoc, \ ::clang::ast_matchers::internal::TypeLocMatcher##MatcherName##Getter, \ ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \ ReturnTypesF>::Func MatcherName##Loc; \ AST_TYPE_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF) /// AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName) works /// identical to \c AST_TYPE_TRAVERSE_MATCHER but operates on \c TypeLocs. #define AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \ namespace internal { \ template <typename T> struct TypeLocMatcher##MatcherName##Getter { \ static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \ }; \ } \ const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \ TypeLoc, \ ::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_MATCHER_REGEX(Type, DefineMatcher, Param) { ... } /// defines a function named DefineMatcher() that takes a regular expression /// string paramater and an optional RegexFlags parameter and returns a /// Matcher<Type> object. /// /// The code between the curly braces has access to the following variables: /// /// Node: the AST node being matched; its type is Type. /// Param: a pointer to an \ref llvm::Regex object /// Finder: an ASTMatchFinder*. /// Builder: a BoundNodesTreeBuilder*. /// /// The code should return true if 'Node' matches. #define AST_MATCHER_REGEX(Type, DefineMatcher, Param) \ AST_MATCHER_REGEX_OVERLOAD(Type, DefineMatcher, Param, 0) #define AST_MATCHER_REGEX_OVERLOAD(Type, DefineMatcher, Param, OverloadId) \ namespace internal { \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \ std::shared_ptr<llvm::Regex> RE) \ : Param(std::move(RE)) {} \ bool matches(const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ std::shared_ptr<llvm::Regex> const Param; \ }; \ } \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags) { \ return ::clang::ast_matchers::internal::makeMatcher( \ new internal::matcher_##DefineMatcher##OverloadId##Matcher( \ ::clang::ast_matchers::internal::createAndVerifyRegex( \ Param, RegexFlags, #DefineMatcher))); \ } \ inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \ llvm::StringRef Param) { \ return DefineMatcher(Param, llvm::Regex::NoFlags); \ } \ \ typedef ::clang::ast_matchers::internal::Matcher<Type> ( \ &DefineMatcher##_Type##OverloadId##Flags)(llvm::StringRef, \ llvm::Regex::RegexFlags); \ typedef ::clang::ast_matchers::internal::Matcher<Type> ( \ &DefineMatcher##_Type##OverloadId)(llvm::StringRef); \ inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \ const Type &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const /// AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param) { ... } /// defines a function named DefineMatcher() that takes a regular expression /// string paramater and an optional RegexFlags parameter that is polymorphic in /// the return type. /// /// The variables are the same as for /// AST_MATCHER_REGEX, with the addition of NodeType, which specifies the node /// type of the matcher Matcher<NodeType> returned by the function matcher(). #define AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param) \ AST_POLYMORPHIC_MATCHER_REGEX_OVERLOAD(DefineMatcher, ReturnTypesF, Param, 0) #define AST_POLYMORPHIC_MATCHER_REGEX_OVERLOAD(DefineMatcher, ReturnTypesF, \ Param, OverloadId) \ namespace internal { \ template <typename NodeType, typename ParamT> \ class matcher_##DefineMatcher##OverloadId##Matcher \ : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \ public: \ explicit matcher_##DefineMatcher##OverloadId##Matcher( \ std::shared_ptr<llvm::Regex> RE) \ : Param(std::move(RE)) {} \ bool matches(const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder \ *Builder) const override; \ \ private: \ std::shared_ptr<llvm::Regex> const Param; \ }; \ } \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, \ std::shared_ptr<llvm::Regex>, ReturnTypesF> \ DefineMatcher(llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags) { \ return ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, \ std::shared_ptr<llvm::Regex>, ReturnTypesF>( \ ::clang::ast_matchers::internal::createAndVerifyRegex( \ Param, RegexFlags, #DefineMatcher)); \ } \ inline ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, \ std::shared_ptr<llvm::Regex>, ReturnTypesF> \ DefineMatcher(llvm::StringRef Param) { \ return DefineMatcher(Param, llvm::Regex::NoFlags); \ } \ typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, \ std::shared_ptr<llvm::Regex>, ReturnTypesF> ( \ &DefineMatcher##_Type##OverloadId##Flags)( \ llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags); \ typedef ::clang::ast_matchers::internal::PolymorphicMatcherWithParam1< \ internal::matcher_##DefineMatcher##OverloadId##Matcher, \ std::shared_ptr<llvm::Regex>, ReturnTypesF> ( \ &DefineMatcher##_Type##OverloadId)(llvm::StringRef Param); \ template <typename NodeType, typename ParamT> \ bool internal:: \ matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \ const NodeType &Node, \ ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \ ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \ const #endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
Upload File
Create Folder