clang 20.0.0git
ASTMatchersMacros.h
Go to the documentation of this file.
1//===--- ASTMatchersMacros.h - Structural query framework -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Defines macros that enable us to define new matchers in a single place.
10// Since a matcher is a function which returns a Matcher<T> object, where
11// T is the type of the actual implementation of the matcher, the macros allow
12// us to write matchers like functions and take care of the definition of the
13// class boilerplate.
14//
15// Note that when you define a matcher with an AST_MATCHER* macro, only the
16// function which creates the matcher goes into the current namespace - the
17// class that implements the actual matcher, which gets returned by the
18// generator function, is put into the 'internal' namespace. This allows us
19// to only have the functions (which is all the user cares about) in the
20// 'ast_matchers' namespace and hide the boilerplate.
21//
22// To define a matcher in user code, put it into your own namespace. This would
23// help to prevent ODR violations in case a matcher with the same name is
24// defined in multiple translation units:
25//
26// namespace my_matchers {
27// AST_MATCHER_P(clang::MemberExpr, Member,
28// clang::ast_matchers::internal::Matcher<clang::ValueDecl>,
29// InnerMatcher) {
30// return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
31// }
32// } // namespace my_matchers
33//
34// Alternatively, an unnamed namespace may be used:
35//
36// namespace clang {
37// namespace ast_matchers {
38// namespace {
39// AST_MATCHER_P(MemberExpr, Member,
40// internal::Matcher<ValueDecl>, InnerMatcher) {
41// return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
42// }
43// } // namespace
44// } // namespace ast_matchers
45// } // namespace clang
46//
47//===----------------------------------------------------------------------===//
48
49#ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
50#define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
51
52/// AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) { ... }
53/// defines a zero parameter function named DefineMatcher() that returns a
54/// ReturnType object.
55#define AST_MATCHER_FUNCTION(ReturnType, DefineMatcher) \
56 inline ReturnType DefineMatcher##_getInstance(); \
57 inline ReturnType DefineMatcher() { \
58 return ::clang::ast_matchers::internal::MemoizedMatcher< \
59 ReturnType, DefineMatcher##_getInstance>::getInstance(); \
60 } \
61 inline ReturnType DefineMatcher##_getInstance()
62
63/// AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) {
64/// ... }
65/// defines a single-parameter function named DefineMatcher() that returns a
66/// ReturnType object.
67///
68/// The code between the curly braces has access to the following variables:
69///
70/// Param: the parameter passed to the function; its type
71/// is ParamType.
72///
73/// The code should return an instance of ReturnType.
74#define AST_MATCHER_FUNCTION_P(ReturnType, DefineMatcher, ParamType, Param) \
75 AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, Param, \
76 0)
77#define AST_MATCHER_FUNCTION_P_OVERLOAD(ReturnType, DefineMatcher, ParamType, \
78 Param, OverloadId) \
79 inline ReturnType DefineMatcher(ParamType const &Param); \
80 typedef ReturnType (&DefineMatcher##_Type##OverloadId)(ParamType const &); \
81 inline ReturnType DefineMatcher(ParamType const &Param)
82
83/// AST_MATCHER(Type, DefineMatcher) { ... }
84/// defines a zero parameter function named DefineMatcher() that returns a
85/// Matcher<Type> object.
86///
87/// The code between the curly braces has access to the following variables:
88///
89/// Node: the AST node being matched; its type is Type.
90/// Finder: an ASTMatchFinder*.
91/// Builder: a BoundNodesTreeBuilder*.
92///
93/// The code should return true if 'Node' matches.
94#define AST_MATCHER(Type, DefineMatcher) \
95 namespace internal { \
96 class matcher_##DefineMatcher##Matcher \
97 : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \
98 public: \
99 explicit matcher_##DefineMatcher##Matcher() = default; \
100 bool matches(const Type &Node, \
101 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
102 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
103 *Builder) const override; \
104 }; \
105 } \
106 inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher() { \
107 return ::clang::ast_matchers::internal::makeMatcher( \
108 new internal::matcher_##DefineMatcher##Matcher()); \
109 } \
110 inline bool internal::matcher_##DefineMatcher##Matcher::matches( \
111 const Type &Node, \
112 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
113 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
114
115/// AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) { ... }
116/// defines a single-parameter function named DefineMatcher() that returns a
117/// Matcher<Type> object.
118///
119/// The code between the curly braces has access to the following variables:
120///
121/// Node: the AST node being matched; its type is Type.
122/// Param: the parameter passed to the function; its type
123/// is ParamType.
124/// Finder: an ASTMatchFinder*.
125/// Builder: a BoundNodesTreeBuilder*.
126///
127/// The code should return true if 'Node' matches.
128#define AST_MATCHER_P(Type, DefineMatcher, ParamType, Param) \
129 AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, 0)
130
131#define AST_MATCHER_P_OVERLOAD(Type, DefineMatcher, ParamType, Param, \
132 OverloadId) \
133 namespace internal { \
134 class matcher_##DefineMatcher##OverloadId##Matcher \
135 : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \
136 public: \
137 explicit matcher_##DefineMatcher##OverloadId##Matcher( \
138 ParamType const &A##Param) \
139 : Param(A##Param) {} \
140 bool matches(const Type &Node, \
141 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
142 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
143 *Builder) const override; \
144 \
145 private: \
146 ParamType Param; \
147 }; \
148 } \
149 inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
150 ParamType const &Param) { \
151 return ::clang::ast_matchers::internal::makeMatcher( \
152 new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param)); \
153 } \
154 typedef ::clang::ast_matchers::internal::Matcher<Type> ( \
155 &DefineMatcher##_Type##OverloadId)(ParamType const &Param); \
156 inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \
157 const Type &Node, \
158 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
159 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
160
161/// AST_MATCHER_P2(
162/// Type, DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... }
163/// defines a two-parameter function named DefineMatcher() that returns a
164/// Matcher<Type> object.
165///
166/// The code between the curly braces has access to the following variables:
167///
168/// Node: the AST node being matched; its type is Type.
169/// Param1, Param2: the parameters passed to the function; their types
170/// are ParamType1 and ParamType2.
171/// Finder: an ASTMatchFinder*.
172/// Builder: a BoundNodesTreeBuilder*.
173///
174/// The code should return true if 'Node' matches.
175#define AST_MATCHER_P2(Type, DefineMatcher, ParamType1, Param1, ParamType2, \
176 Param2) \
177 AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, ParamType2, \
178 Param2, 0)
179
180#define AST_MATCHER_P2_OVERLOAD(Type, DefineMatcher, ParamType1, Param1, \
181 ParamType2, Param2, OverloadId) \
182 namespace internal { \
183 class matcher_##DefineMatcher##OverloadId##Matcher \
184 : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \
185 public: \
186 matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
187 ParamType2 const &A##Param2) \
188 : Param1(A##Param1), Param2(A##Param2) {} \
189 bool matches(const Type &Node, \
190 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
191 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
192 *Builder) const override; \
193 \
194 private: \
195 ParamType1 Param1; \
196 ParamType2 Param2; \
197 }; \
198 } \
199 inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
200 ParamType1 const &Param1, ParamType2 const &Param2) { \
201 return ::clang::ast_matchers::internal::makeMatcher( \
202 new internal::matcher_##DefineMatcher##OverloadId##Matcher(Param1, \
203 Param2)); \
204 } \
205 typedef ::clang::ast_matchers::internal::Matcher<Type> ( \
206 &DefineMatcher##_Type##OverloadId)(ParamType1 const &Param1, \
207 ParamType2 const &Param2); \
208 inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \
209 const Type &Node, \
210 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
211 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
212
213/// Construct a type-list to be passed to the AST_POLYMORPHIC_MATCHER*
214/// macros.
215///
216/// You can't pass something like \c TypeList<Foo, Bar> to a macro, because it
217/// will look at that as two arguments. However, you can pass
218/// \c void(TypeList<Foo, Bar>), which works thanks to the parenthesis.
219/// The \c PolymorphicMatcherWithParam* classes will unpack the function type to
220/// extract the TypeList object.
221#define AST_POLYMORPHIC_SUPPORTED_TYPES(...) \
222 void(::clang::ast_matchers::internal::TypeList<__VA_ARGS__>)
223
224/// AST_POLYMORPHIC_MATCHER(DefineMatcher) { ... }
225/// defines a single-parameter function named DefineMatcher() that is
226/// polymorphic in the return type.
227///
228/// The variables are the same as for AST_MATCHER, but NodeType will be deduced
229/// from the calling context.
230#define AST_POLYMORPHIC_MATCHER(DefineMatcher, ReturnTypesF) \
231 namespace internal { \
232 template <typename NodeType> \
233 class matcher_##DefineMatcher##Matcher \
234 : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
235 public: \
236 bool matches(const NodeType &Node, \
237 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
238 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
239 *Builder) const override; \
240 }; \
241 } \
242 inline ::clang::ast_matchers::internal::PolymorphicMatcher< \
243 internal::matcher_##DefineMatcher##Matcher, ReturnTypesF> \
244 DefineMatcher() { \
245 return ::clang::ast_matchers::internal::PolymorphicMatcher< \
246 internal::matcher_##DefineMatcher##Matcher, ReturnTypesF>(); \
247 } \
248 template <typename NodeType> \
249 bool internal::matcher_##DefineMatcher##Matcher<NodeType>::matches( \
250 const NodeType &Node, \
251 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
252 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
253
254/// AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ParamType, Param) { ... }
255/// defines a single-parameter function named DefineMatcher() that is
256/// polymorphic in the return type.
257///
258/// The variables are the same as for
259/// AST_MATCHER_P, with the addition of NodeType, which specifies the node type
260/// of the matcher Matcher<NodeType> returned by the function matcher().
261///
262/// FIXME: Pull out common code with above macro?
263#define AST_POLYMORPHIC_MATCHER_P(DefineMatcher, ReturnTypesF, ParamType, \
264 Param) \
265 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType, \
266 Param, 0)
267
268#define AST_POLYMORPHIC_MATCHER_P_OVERLOAD(DefineMatcher, ReturnTypesF, \
269 ParamType, Param, OverloadId) \
270 namespace internal { \
271 template <typename NodeType, typename ParamT> \
272 class matcher_##DefineMatcher##OverloadId##Matcher \
273 : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
274 public: \
275 explicit matcher_##DefineMatcher##OverloadId##Matcher( \
276 ParamType const &A##Param) \
277 : Param(A##Param) {} \
278 bool matches(const NodeType &Node, \
279 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
280 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
281 *Builder) const override; \
282 \
283 private: \
284 ParamType Param; \
285 }; \
286 } \
287 inline ::clang::ast_matchers::internal::PolymorphicMatcher< \
288 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
289 ParamType> \
290 DefineMatcher(ParamType const &Param) { \
291 return ::clang::ast_matchers::internal::PolymorphicMatcher< \
292 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
293 ParamType>(Param); \
294 } \
295 typedef ::clang::ast_matchers::internal::PolymorphicMatcher< \
296 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
297 ParamType> (&DefineMatcher##_Type##OverloadId)(ParamType const &Param); \
298 template <typename NodeType, typename ParamT> \
299 bool internal:: \
300 matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \
301 const NodeType &Node, \
302 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
303 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \
304 const
305
306/// AST_POLYMORPHIC_MATCHER_P2(
307/// DefineMatcher, ParamType1, Param1, ParamType2, Param2) { ... }
308/// defines a two-parameter function named matcher() that is polymorphic in
309/// the return type.
310///
311/// The variables are the same as for AST_MATCHER_P2, with the
312/// addition of NodeType, which specifies the node type of the matcher
313/// Matcher<NodeType> returned by the function DefineMatcher().
314#define AST_POLYMORPHIC_MATCHER_P2(DefineMatcher, ReturnTypesF, ParamType1, \
315 Param1, ParamType2, Param2) \
316 AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, ParamType1, \
317 Param1, ParamType2, Param2, 0)
318
319#define AST_POLYMORPHIC_MATCHER_P2_OVERLOAD(DefineMatcher, ReturnTypesF, \
320 ParamType1, Param1, ParamType2, \
321 Param2, OverloadId) \
322 namespace internal { \
323 template <typename NodeType, typename ParamT1, typename ParamT2> \
324 class matcher_##DefineMatcher##OverloadId##Matcher \
325 : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
326 public: \
327 matcher_##DefineMatcher##OverloadId##Matcher(ParamType1 const &A##Param1, \
328 ParamType2 const &A##Param2) \
329 : Param1(A##Param1), Param2(A##Param2) {} \
330 bool matches(const NodeType &Node, \
331 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
332 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
333 *Builder) const override; \
334 \
335 private: \
336 ParamType1 Param1; \
337 ParamType2 Param2; \
338 }; \
339 } \
340 inline ::clang::ast_matchers::internal::PolymorphicMatcher< \
341 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
342 ParamType1, ParamType2> \
343 DefineMatcher(ParamType1 const &Param1, ParamType2 const &Param2) { \
344 return ::clang::ast_matchers::internal::PolymorphicMatcher< \
345 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
346 ParamType1, ParamType2>(Param1, Param2); \
347 } \
348 typedef ::clang::ast_matchers::internal::PolymorphicMatcher< \
349 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
350 ParamType1, ParamType2> (&DefineMatcher##_Type##OverloadId)( \
351 ParamType1 const &Param1, ParamType2 const &Param2); \
352 template <typename NodeType, typename ParamT1, typename ParamT2> \
353 bool internal::matcher_##DefineMatcher##OverloadId##Matcher< \
354 NodeType, ParamT1, ParamT2>:: \
355 matches(const NodeType &Node, \
356 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
357 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \
358 const
359
360// FIXME: add a matcher for TypeLoc derived classes using its custom casting
361// API (no longer dyn_cast) if/when we need such matching
362
363#define AST_TYPE_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName, \
364 ReturnTypesF) \
365 namespace internal { \
366 template <typename T> struct TypeMatcher##MatcherName##Getter { \
367 static QualType (T::*value())() const { return &T::FunctionName; } \
368 }; \
369 } \
370 extern const ::clang::ast_matchers::internal:: \
371 TypeTraversePolymorphicMatcher< \
372 QualType, \
373 ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \
374 ::clang::ast_matchers::internal::TypeTraverseMatcher, \
375 ReturnTypesF>::Func MatcherName
376
377#define AST_TYPE_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF) \
378 const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
379 QualType, \
380 ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \
381 ::clang::ast_matchers::internal::TypeTraverseMatcher, \
382 ReturnTypesF>::Func MatcherName
383
384/// AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName) defines
385/// the matcher \c MatcherName that can be used to traverse from one \c Type
386/// to another.
387///
388/// For a specific \c SpecificType, the traversal is done using
389/// \c SpecificType::FunctionName. The existence of such a function determines
390/// whether a corresponding matcher can be used on \c SpecificType.
391#define AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \
392 namespace internal { \
393 template <typename T> struct TypeMatcher##MatcherName##Getter { \
394 static QualType (T::*value())() const { return &T::FunctionName; } \
395 }; \
396 } \
397 const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
398 QualType, \
399 ::clang::ast_matchers::internal::TypeMatcher##MatcherName##Getter, \
400 ::clang::ast_matchers::internal::TypeTraverseMatcher, \
401 ReturnTypesF>::Func MatcherName
402
403#define AST_TYPELOC_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName, \
404 ReturnTypesF) \
405 namespace internal { \
406 template <typename T> struct TypeLocMatcher##MatcherName##Getter { \
407 static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \
408 }; \
409 } \
410 extern const ::clang::ast_matchers::internal:: \
411 TypeTraversePolymorphicMatcher< \
412 TypeLoc, \
413 ::clang::ast_matchers::internal:: \
414 TypeLocMatcher##MatcherName##Getter, \
415 ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \
416 ReturnTypesF>::Func MatcherName##Loc; \
417 AST_TYPE_TRAVERSE_MATCHER_DECL(MatcherName, FunctionName##Type, ReturnTypesF)
418
419#define AST_TYPELOC_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF) \
420 const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
421 TypeLoc, \
422 ::clang::ast_matchers::internal::TypeLocMatcher##MatcherName##Getter, \
423 ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \
424 ReturnTypesF>::Func MatcherName##Loc; \
425 AST_TYPE_TRAVERSE_MATCHER_DEF(MatcherName, ReturnTypesF)
426
427/// AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName) works
428/// identical to \c AST_TYPE_TRAVERSE_MATCHER but operates on \c TypeLocs.
429#define AST_TYPELOC_TRAVERSE_MATCHER(MatcherName, FunctionName, ReturnTypesF) \
430 namespace internal { \
431 template <typename T> struct TypeLocMatcher##MatcherName##Getter { \
432 static TypeLoc (T::*value())() const { return &T::FunctionName##Loc; } \
433 }; \
434 } \
435 const ::clang::ast_matchers::internal::TypeTraversePolymorphicMatcher< \
436 TypeLoc, \
437 ::clang::ast_matchers::internal::TypeLocMatcher##MatcherName##Getter, \
438 ::clang::ast_matchers::internal::TypeLocTraverseMatcher, \
439 ReturnTypesF>::Func MatcherName##Loc; \
440 AST_TYPE_TRAVERSE_MATCHER(MatcherName, FunctionName##Type, ReturnTypesF)
441
442/// AST_MATCHER_REGEX(Type, DefineMatcher, Param) { ... }
443/// defines a function named DefineMatcher() that takes a regular expression
444/// string paramater and an optional RegexFlags parameter and returns a
445/// Matcher<Type> object.
446///
447/// The code between the curly braces has access to the following variables:
448///
449/// Node: the AST node being matched; its type is Type.
450/// Param: a pointer to an \ref llvm::Regex object
451/// Finder: an ASTMatchFinder*.
452/// Builder: a BoundNodesTreeBuilder*.
453///
454/// The code should return true if 'Node' matches.
455#define AST_MATCHER_REGEX(Type, DefineMatcher, Param) \
456 AST_MATCHER_REGEX_OVERLOAD(Type, DefineMatcher, Param, 0)
457
458#define AST_MATCHER_REGEX_OVERLOAD(Type, DefineMatcher, Param, OverloadId) \
459 namespace internal { \
460 class matcher_##DefineMatcher##OverloadId##Matcher \
461 : public ::clang::ast_matchers::internal::MatcherInterface<Type> { \
462 public: \
463 explicit matcher_##DefineMatcher##OverloadId##Matcher( \
464 std::shared_ptr<llvm::Regex> RE) \
465 : Param(std::move(RE)) {} \
466 bool matches(const Type &Node, \
467 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
468 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
469 *Builder) const override; \
470 \
471 private: \
472 std::shared_ptr<llvm::Regex> Param; \
473 }; \
474 } \
475 inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
476 llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags) { \
477 return ::clang::ast_matchers::internal::makeMatcher( \
478 new internal::matcher_##DefineMatcher##OverloadId##Matcher( \
479 ::clang::ast_matchers::internal::createAndVerifyRegex( \
480 Param, RegexFlags, #DefineMatcher))); \
481 } \
482 inline ::clang::ast_matchers::internal::Matcher<Type> DefineMatcher( \
483 llvm::StringRef Param) { \
484 return DefineMatcher(Param, llvm::Regex::NoFlags); \
485 } \
486 \
487 typedef ::clang::ast_matchers::internal::Matcher<Type> ( \
488 &DefineMatcher##_Type##OverloadId##Flags)(llvm::StringRef, \
489 llvm::Regex::RegexFlags); \
490 typedef ::clang::ast_matchers::internal::Matcher<Type> ( \
491 &DefineMatcher##_Type##OverloadId)(llvm::StringRef); \
492 inline bool internal::matcher_##DefineMatcher##OverloadId##Matcher::matches( \
493 const Type &Node, \
494 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
495 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) const
496
497/// AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param) { ... }
498/// defines a function named DefineMatcher() that takes a regular expression
499/// string paramater and an optional RegexFlags parameter that is polymorphic in
500/// the return type.
501///
502/// The variables are the same as for
503/// AST_MATCHER_REGEX, with the addition of NodeType, which specifies the node
504/// type of the matcher Matcher<NodeType> returned by the function matcher().
505#define AST_POLYMORPHIC_MATCHER_REGEX(DefineMatcher, ReturnTypesF, Param) \
506 AST_POLYMORPHIC_MATCHER_REGEX_OVERLOAD(DefineMatcher, ReturnTypesF, Param, 0)
507
508#define AST_POLYMORPHIC_MATCHER_REGEX_OVERLOAD(DefineMatcher, ReturnTypesF, \
509 Param, OverloadId) \
510 namespace internal { \
511 template <typename NodeType, typename ParamT> \
512 class matcher_##DefineMatcher##OverloadId##Matcher \
513 : public ::clang::ast_matchers::internal::MatcherInterface<NodeType> { \
514 public: \
515 explicit matcher_##DefineMatcher##OverloadId##Matcher( \
516 std::shared_ptr<llvm::Regex> RE) \
517 : Param(std::move(RE)) {} \
518 bool matches(const NodeType &Node, \
519 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
520 ::clang::ast_matchers::internal::BoundNodesTreeBuilder \
521 *Builder) const override; \
522 \
523 private: \
524 std::shared_ptr<llvm::Regex> Param; \
525 }; \
526 } \
527 inline ::clang::ast_matchers::internal::PolymorphicMatcher< \
528 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
529 std::shared_ptr<llvm::Regex>> \
530 DefineMatcher(llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags) { \
531 return ::clang::ast_matchers::internal::PolymorphicMatcher< \
532 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
533 std::shared_ptr<llvm::Regex>>( \
534 ::clang::ast_matchers::internal::createAndVerifyRegex( \
535 Param, RegexFlags, #DefineMatcher)); \
536 } \
537 inline ::clang::ast_matchers::internal::PolymorphicMatcher< \
538 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
539 std::shared_ptr<llvm::Regex>> \
540 DefineMatcher(llvm::StringRef Param) { \
541 return DefineMatcher(Param, llvm::Regex::NoFlags); \
542 } \
543 typedef ::clang::ast_matchers::internal::PolymorphicMatcher< \
544 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
545 std::shared_ptr<llvm::Regex>> ( \
546 &DefineMatcher##_Type##OverloadId##Flags)( \
547 llvm::StringRef Param, llvm::Regex::RegexFlags RegexFlags); \
548 typedef ::clang::ast_matchers::internal::PolymorphicMatcher< \
549 internal::matcher_##DefineMatcher##OverloadId##Matcher, ReturnTypesF, \
550 std::shared_ptr<llvm::Regex>> (&DefineMatcher##_Type##OverloadId)( \
551 llvm::StringRef Param); \
552 template <typename NodeType, typename ParamT> \
553 bool internal:: \
554 matcher_##DefineMatcher##OverloadId##Matcher<NodeType, ParamT>::matches( \
555 const NodeType &Node, \
556 ::clang::ast_matchers::internal::ASTMatchFinder *Finder, \
557 ::clang::ast_matchers::internal::BoundNodesTreeBuilder *Builder) \
558 const
559
560#endif // LLVM_CLANG_ASTMATCHERS_ASTMATCHERSMACROS_H
Generated on Fri Nov 22 2024 09:47:13 for clang by doxygen 1.9.6