[clang-tidy] Fix crash in readability-function-cognitive-complexity on weak refs
[lldb.git] / clang / docs / LibASTMatchersReference.html
1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2           "http://www.w3.org/TR/html4/strict.dtd">
3 <html>
4 <head>
5 <title>AST Matcher Reference</title>
6 <link type="text/css" rel="stylesheet" href="../menu.css" />
7 <link type="text/css" rel="stylesheet" href="../content.css" />
8 <style type="text/css">
9 td {
10   padding: .33em;
11 }
12 td.doc {
13   display: none;
14   border-bottom: 1px solid black;
15 }
16 td.name:hover {
17   color: blue;
18   cursor: pointer;
19 }
20 </style>
21 <script type="text/javascript">
22 function toggle(id) {
23   if (!id) return;
24   row = document.getElementById(id);
25   if (row.style.display != 'table-cell')
26     row.style.display = 'table-cell';
27   else
28     row.style.display = 'none';
29 }
30 </script>
31 </head>
32 <body onLoad="toggle(location.hash.substring(1, location.hash.length - 6))">
33
34 <!--#include virtual="../menu.html.incl"-->
35
36 <div id="content">
37
38 <h1>AST Matcher Reference</h1>
39
40 <p>This document shows all currently implemented matchers. The matchers are grouped
41 by category and node type they match. You can click on matcher names to show the
42 matcher's source documentation.</p>
43
44 <p>There are three different basic categories of matchers:
45 <ul>
46 <li><a href="#decl-matchers">Node Matchers:</a> Matchers that match a specific type of AST node.</li>
47 <li><a href="#narrowing-matchers">Narrowing Matchers:</a> Matchers that match attributes on AST nodes.</li>
48 <li><a href="#traversal-matchers">Traversal Matchers:</a> Matchers that allow traversal between AST nodes.</li>
49 </ul>
50 </p>
51
52 <p>Within each category the matchers are ordered by node type they match on.
53 Note that if a matcher can match multiple node types, it will appear
54 multiple times. This means that by searching for Matcher&lt;Stmt&gt; you can
55 find all matchers that can be used to match on Stmt nodes.</p>
56
57 <p>The exception to that rule are matchers that can match on any node. Those
58 are marked with a * and are listed in the beginning of each category.</p>
59
60 <p>Note that the categorization of matchers is a great help when you combine
61 them into matcher expressions. You will usually want to form matcher expressions
62 that read like english sentences by alternating between node matchers and
63 narrowing or traversal matchers, like this:
64 <pre>
65 recordDecl(hasDescendant(
66     ifStmt(hasTrueExpression(
67         expr(hasDescendant(
68             ifStmt()))))))
69 </pre>
70 </p>
71
72 <!-- ======================================================================= -->
73 <h2 id="decl-matchers">Node Matchers</h2>
74 <!-- ======================================================================= -->
75
76 <p>Node matchers are at the core of matcher expressions - they specify the type
77 of node that is expected. Every match expression starts with a node matcher,
78 which can then be further refined with a narrowing or traversal matcher. All
79 traversal matchers take node matchers as their arguments.</p>
80
81 <p>For convenience, all node matchers take an arbitrary number of arguments
82 and implicitly act as allOf matchers.</p>
83
84 <p>Node matchers are the only matchers that support the bind("id") call to
85 bind the matched node to the given string, to be later retrieved from the
86 match callback.</p>
87
88 <p>It is important to remember that the arguments to node matchers are
89 predicates on the same node, just with additional information about the type.
90 This is often useful to make matcher expression more readable by inlining bind
91 calls into redundant node matchers inside another node matcher:
92 <pre>
93 // This binds the CXXRecordDecl to "id", as the decl() matcher will stay on
94 // the same node.
95 recordDecl(decl().bind("id"), hasName("::MyClass"))
96 </pre>
97 </p>
98
99 <table>
100 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
101 <!-- START_DECL_MATCHERS -->
102
103 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('cxxCtorInitializer0')"><a name="cxxCtorInitializer0Anchor">cxxCtorInitializer</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;...</td></tr>
104 <tr><td colspan="4" class="doc" id="cxxCtorInitializer0"><pre>Matches constructor initializers.
105
106 Examples matches i(42).
107   class C {
108     C() : i(42) {}
109     int i;
110   };
111 </pre></td></tr>
112
113
114 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('accessSpecDecl0')"><a name="accessSpecDecl0Anchor">accessSpecDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AccessSpecDecl.html">AccessSpecDecl</a>&gt;...</td></tr>
115 <tr><td colspan="4" class="doc" id="accessSpecDecl0"><pre>Matches C++ access specifier declarations.
116
117 Given
118   class C {
119   public:
120     int a;
121   };
122 accessSpecDecl()
123   matches 'public:'
124 </pre></td></tr>
125
126
127 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('blockDecl0')"><a name="blockDecl0Anchor">blockDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockDecl.html">BlockDecl</a>&gt;...</td></tr>
128 <tr><td colspan="4" class="doc" id="blockDecl0"><pre>Matches block declarations.
129
130 Example matches the declaration of the nameless block printing an input
131 integer.
132
133   myFunc(^(int p) {
134     printf("%d", p);
135   })
136 </pre></td></tr>
137
138
139 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplateDecl0')"><a name="classTemplateDecl0Anchor">classTemplateDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateDecl.html">ClassTemplateDecl</a>&gt;...</td></tr>
140 <tr><td colspan="4" class="doc" id="classTemplateDecl0"><pre>Matches C++ class template declarations.
141
142 Example matches Z
143   template&lt;class T&gt; class Z {};
144 </pre></td></tr>
145
146
147 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplatePartialSpecializationDecl0')"><a name="classTemplatePartialSpecializationDecl0Anchor">classTemplatePartialSpecializationDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplatePartialSpecializationDecl.html">ClassTemplatePartialSpecializationDecl</a>&gt;...</td></tr>
148 <tr><td colspan="4" class="doc" id="classTemplatePartialSpecializationDecl0"><pre>Matches C++ class template partial specializations.
149
150 Given
151   template&lt;class T1, class T2, int I&gt;
152   class A {};
153
154   template&lt;class T, int I&gt;
155   class A&lt;T, T*, I&gt; {};
156
157   template&lt;&gt;
158   class A&lt;int, int, 1&gt; {};
159 classTemplatePartialSpecializationDecl()
160   matches the specialization A&lt;T,T*,I&gt; but not A&lt;int,int,1&gt;
161 </pre></td></tr>
162
163
164 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('classTemplateSpecializationDecl0')"><a name="classTemplateSpecializationDecl0Anchor">classTemplateSpecializationDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;...</td></tr>
165 <tr><td colspan="4" class="doc" id="classTemplateSpecializationDecl0"><pre>Matches C++ class template specializations.
166
167 Given
168   template&lt;typename T&gt; class A {};
169   template&lt;&gt; class A&lt;double&gt; {};
170   A&lt;int&gt; a;
171 classTemplateSpecializationDecl()
172   matches the specializations A&lt;int&gt; and A&lt;double&gt;
173 </pre></td></tr>
174
175
176 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxConstructorDecl0')"><a name="cxxConstructorDecl0Anchor">cxxConstructorDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;...</td></tr>
177 <tr><td colspan="4" class="doc" id="cxxConstructorDecl0"><pre>Matches C++ constructor declarations.
178
179 Example matches Foo::Foo() and Foo::Foo(int)
180   class Foo {
181    public:
182     Foo();
183     Foo(int);
184     int DoSomething();
185   };
186 </pre></td></tr>
187
188
189 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxConversionDecl0')"><a name="cxxConversionDecl0Anchor">cxxConversionDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConversionDecl.html">CXXConversionDecl</a>&gt;...</td></tr>
190 <tr><td colspan="4" class="doc" id="cxxConversionDecl0"><pre>Matches conversion operator declarations.
191
192 Example matches the operator.
193   class X { operator int() const; };
194 </pre></td></tr>
195
196
197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxDeductionGuideDecl0')"><a name="cxxDeductionGuideDecl0Anchor">cxxDeductionGuideDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDeductionGuideDecl.html">CXXDeductionGuideDecl</a>&gt;...</td></tr>
198 <tr><td colspan="4" class="doc" id="cxxDeductionGuideDecl0"><pre>Matches user-defined and implicitly generated deduction guide.
199
200 Example matches the deduction guide.
201   template&lt;typename T&gt;
202   class X { X(int) };
203   X(int) -&gt; X&lt;int&gt;;
204 </pre></td></tr>
205
206
207 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxDestructorDecl0')"><a name="cxxDestructorDecl0Anchor">cxxDestructorDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDestructorDecl.html">CXXDestructorDecl</a>&gt;...</td></tr>
208 <tr><td colspan="4" class="doc" id="cxxDestructorDecl0"><pre>Matches explicit C++ destructor declarations.
209
210 Example matches Foo::~Foo()
211   class Foo {
212    public:
213     virtual ~Foo();
214   };
215 </pre></td></tr>
216
217
218 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxMethodDecl0')"><a name="cxxMethodDecl0Anchor">cxxMethodDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;...</td></tr>
219 <tr><td colspan="4" class="doc" id="cxxMethodDecl0"><pre>Matches method declarations.
220
221 Example matches y
222   class X { void y(); };
223 </pre></td></tr>
224
225
226 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('cxxRecordDecl0')"><a name="cxxRecordDecl0Anchor">cxxRecordDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;...</td></tr>
227 <tr><td colspan="4" class="doc" id="cxxRecordDecl0"><pre>Matches C++ class declarations.
228
229 Example matches X, Z
230   class X;
231   template&lt;class T&gt; class Z {};
232 </pre></td></tr>
233
234
235 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('decl0')"><a name="decl0Anchor">decl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;...</td></tr>
236 <tr><td colspan="4" class="doc" id="decl0"><pre>Matches declarations.
237
238 Examples matches X, C, and the friend declaration inside C;
239   void X();
240   class C {
241     friend X;
242   };
243 </pre></td></tr>
244
245
246 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('declaratorDecl0')"><a name="declaratorDecl0Anchor">declaratorDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclaratorDecl.html">DeclaratorDecl</a>&gt;...</td></tr>
247 <tr><td colspan="4" class="doc" id="declaratorDecl0"><pre>Matches declarator declarations (field, variable, function
248 and non-type template parameter declarations).
249
250 Given
251   class X { int y; };
252 declaratorDecl()
253   matches int y.
254 </pre></td></tr>
255
256
257 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('enumConstantDecl0')"><a name="enumConstantDecl0Anchor">enumConstantDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumConstantDecl.html">EnumConstantDecl</a>&gt;...</td></tr>
258 <tr><td colspan="4" class="doc" id="enumConstantDecl0"><pre>Matches enum constants.
259
260 Example matches A, B, C
261   enum X {
262     A, B, C
263   };
264 </pre></td></tr>
265
266
267 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('enumDecl0')"><a name="enumDecl0Anchor">enumDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumDecl.html">EnumDecl</a>&gt;...</td></tr>
268 <tr><td colspan="4" class="doc" id="enumDecl0"><pre>Matches enum declarations.
269
270 Example matches X
271   enum X {
272     A, B, C
273   };
274 </pre></td></tr>
275
276
277 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('fieldDecl0')"><a name="fieldDecl0Anchor">fieldDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;...</td></tr>
278 <tr><td colspan="4" class="doc" id="fieldDecl0"><pre>Matches field declarations.
279
280 Given
281   class X { int m; };
282 fieldDecl()
283   matches 'm'.
284 </pre></td></tr>
285
286
287 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('friendDecl0')"><a name="friendDecl0Anchor">friendDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FriendDecl.html">FriendDecl</a>&gt;...</td></tr>
288 <tr><td colspan="4" class="doc" id="friendDecl0"><pre>Matches friend declarations.
289
290 Given
291   class X { friend void foo(); };
292 friendDecl()
293   matches 'friend void foo()'.
294 </pre></td></tr>
295
296
297 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('functionDecl0')"><a name="functionDecl0Anchor">functionDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;...</td></tr>
298 <tr><td colspan="4" class="doc" id="functionDecl0"><pre>Matches function declarations.
299
300 Example matches f
301   void f();
302 </pre></td></tr>
303
304
305 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('functionTemplateDecl0')"><a name="functionTemplateDecl0Anchor">functionTemplateDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionTemplateDecl.html">FunctionTemplateDecl</a>&gt;...</td></tr>
306 <tr><td colspan="4" class="doc" id="functionTemplateDecl0"><pre>Matches C++ function template declarations.
307
308 Example matches f
309   template&lt;class T&gt; void f(T t) {}
310 </pre></td></tr>
311
312
313 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('indirectFieldDecl0')"><a name="indirectFieldDecl0Anchor">indirectFieldDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IndirectFieldDecl.html">IndirectFieldDecl</a>&gt;...</td></tr>
314 <tr><td colspan="4" class="doc" id="indirectFieldDecl0"><pre>Matches indirect field declarations.
315
316 Given
317   struct X { struct { int a; }; };
318 indirectFieldDecl()
319   matches 'a'.
320 </pre></td></tr>
321
322
323 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('labelDecl0')"><a name="labelDecl0Anchor">labelDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelDecl.html">LabelDecl</a>&gt;...</td></tr>
324 <tr><td colspan="4" class="doc" id="labelDecl0"><pre>Matches a declaration of label.
325
326 Given
327   goto FOO;
328   FOO: bar();
329 labelDecl()
330   matches 'FOO:'
331 </pre></td></tr>
332
333
334 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('linkageSpecDecl0')"><a name="linkageSpecDecl0Anchor">linkageSpecDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LinkageSpecDecl.html">LinkageSpecDecl</a>&gt;...</td></tr>
335 <tr><td colspan="4" class="doc" id="linkageSpecDecl0"><pre>Matches a declaration of a linkage specification.
336
337 Given
338   extern "C" {}
339 linkageSpecDecl()
340   matches "extern "C" {}"
341 </pre></td></tr>
342
343
344 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namedDecl0')"><a name="namedDecl0Anchor">namedDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamedDecl.html">NamedDecl</a>&gt;...</td></tr>
345 <tr><td colspan="4" class="doc" id="namedDecl0"><pre>Matches a declaration of anything that could have a name.
346
347 Example matches X, S, the anonymous union type, i, and U;
348   typedef int X;
349   struct S {
350     union {
351       int i;
352     } U;
353   };
354 </pre></td></tr>
355
356
357 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namespaceAliasDecl0')"><a name="namespaceAliasDecl0Anchor">namespaceAliasDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamespaceAliasDecl.html">NamespaceAliasDecl</a>&gt;...</td></tr>
358 <tr><td colspan="4" class="doc" id="namespaceAliasDecl0"><pre>Matches a declaration of a namespace alias.
359
360 Given
361   namespace test {}
362   namespace alias = ::test;
363 namespaceAliasDecl()
364   matches "namespace alias" but not "namespace test"
365 </pre></td></tr>
366
367
368 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('namespaceDecl0')"><a name="namespaceDecl0Anchor">namespaceDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NamespaceDecl.html">NamespaceDecl</a>&gt;...</td></tr>
369 <tr><td colspan="4" class="doc" id="namespaceDecl0"><pre>Matches a declaration of a namespace.
370
371 Given
372   namespace {}
373   namespace test {}
374 namespaceDecl()
375   matches "namespace {}" and "namespace test {}"
376 </pre></td></tr>
377
378
379 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('nonTypeTemplateParmDecl0')"><a name="nonTypeTemplateParmDecl0Anchor">nonTypeTemplateParmDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NonTypeTemplateParmDecl.html">NonTypeTemplateParmDecl</a>&gt;...</td></tr>
380 <tr><td colspan="4" class="doc" id="nonTypeTemplateParmDecl0"><pre>Matches non-type template parameter declarations.
381
382 Given
383   template &lt;typename T, int N&gt; struct C {};
384 nonTypeTemplateParmDecl()
385   matches 'N', but not 'T'.
386 </pre></td></tr>
387
388
389 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcCategoryDecl0')"><a name="objcCategoryDecl0Anchor">objcCategoryDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCCategoryDecl.html">ObjCCategoryDecl</a>&gt;...</td></tr>
390 <tr><td colspan="4" class="doc" id="objcCategoryDecl0"><pre>Matches Objective-C category declarations.
391
392 Example matches Foo (Additions)
393   @interface Foo (Additions)
394   @end
395 </pre></td></tr>
396
397
398 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcCategoryImplDecl0')"><a name="objcCategoryImplDecl0Anchor">objcCategoryImplDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCCategoryImplDecl.html">ObjCCategoryImplDecl</a>&gt;...</td></tr>
399 <tr><td colspan="4" class="doc" id="objcCategoryImplDecl0"><pre>Matches Objective-C category definitions.
400
401 Example matches Foo (Additions)
402   @implementation Foo (Additions)
403   @end
404 </pre></td></tr>
405
406
407 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcImplementationDecl0')"><a name="objcImplementationDecl0Anchor">objcImplementationDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCImplementationDecl.html">ObjCImplementationDecl</a>&gt;...</td></tr>
408 <tr><td colspan="4" class="doc" id="objcImplementationDecl0"><pre>Matches Objective-C implementation declarations.
409
410 Example matches Foo
411   @implementation Foo
412   @end
413 </pre></td></tr>
414
415
416 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcInterfaceDecl0')"><a name="objcInterfaceDecl0Anchor">objcInterfaceDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCInterfaceDecl.html">ObjCInterfaceDecl</a>&gt;...</td></tr>
417 <tr><td colspan="4" class="doc" id="objcInterfaceDecl0"><pre>Matches Objective-C interface declarations.
418
419 Example matches Foo
420   @interface Foo
421   @end
422 </pre></td></tr>
423
424
425 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcIvarDecl0')"><a name="objcIvarDecl0Anchor">objcIvarDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCIvarDecl.html">ObjCIvarDecl</a>&gt;...</td></tr>
426 <tr><td colspan="4" class="doc" id="objcIvarDecl0"><pre>Matches Objective-C instance variable declarations.
427
428 Example matches _enabled
429   @implementation Foo {
430     BOOL _enabled;
431   }
432   @end
433 </pre></td></tr>
434
435
436 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcMethodDecl0')"><a name="objcMethodDecl0Anchor">objcMethodDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMethodDecl.html">ObjCMethodDecl</a>&gt;...</td></tr>
437 <tr><td colspan="4" class="doc" id="objcMethodDecl0"><pre>Matches Objective-C method declarations.
438
439 Example matches both declaration and definition of -[Foo method]
440   @interface Foo
441   - (void)method;
442   @end
443
444   @implementation Foo
445   - (void)method {}
446   @end
447 </pre></td></tr>
448
449
450 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcPropertyDecl0')"><a name="objcPropertyDecl0Anchor">objcPropertyDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCPropertyDecl.html">ObjCPropertyDecl</a>&gt;...</td></tr>
451 <tr><td colspan="4" class="doc" id="objcPropertyDecl0"><pre>Matches Objective-C property declarations.
452
453 Example matches enabled
454   @interface Foo
455   @property BOOL enabled;
456   @end
457 </pre></td></tr>
458
459
460 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('objcProtocolDecl0')"><a name="objcProtocolDecl0Anchor">objcProtocolDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCProtocolDecl.html">ObjCProtocolDecl</a>&gt;...</td></tr>
461 <tr><td colspan="4" class="doc" id="objcProtocolDecl0"><pre>Matches Objective-C protocol declarations.
462
463 Example matches FooDelegate
464   @protocol FooDelegate
465   @end
466 </pre></td></tr>
467
468
469 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('parmVarDecl0')"><a name="parmVarDecl0Anchor">parmVarDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParmVarDecl.html">ParmVarDecl</a>&gt;...</td></tr>
470 <tr><td colspan="4" class="doc" id="parmVarDecl0"><pre>Matches parameter variable declarations.
471
472 Given
473   void f(int x);
474 parmVarDecl()
475   matches int x.
476 </pre></td></tr>
477
478
479 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('recordDecl0')"><a name="recordDecl0Anchor">recordDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordDecl.html">RecordDecl</a>&gt;...</td></tr>
480 <tr><td colspan="4" class="doc" id="recordDecl0"><pre>Matches class, struct, and union declarations.
481
482 Example matches X, Z, U, and S
483   class X;
484   template&lt;class T&gt; class Z {};
485   struct S {};
486   union U {};
487 </pre></td></tr>
488
489
490 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('staticAssertDecl0')"><a name="staticAssertDecl0Anchor">staticAssertDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StaticAssertDecl.html">StaticAssertDecl</a>&gt;...</td></tr>
491 <tr><td colspan="4" class="doc" id="staticAssertDecl0"><pre>Matches a C++ static_assert declaration.
492
493 Example:
494   staticAssertExpr()
495 matches
496   static_assert(sizeof(S) == sizeof(int))
497 in
498   struct S {
499     int x;
500   };
501   static_assert(sizeof(S) == sizeof(int));
502 </pre></td></tr>
503
504
505 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('tagDecl0')"><a name="tagDecl0Anchor">tagDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagDecl.html">TagDecl</a>&gt;...</td></tr>
506 <tr><td colspan="4" class="doc" id="tagDecl0"><pre>Matches tag declarations.
507
508 Example matches X, Z, U, S, E
509   class X;
510   template&lt;class T&gt; class Z {};
511   struct S {};
512   union U {};
513   enum E {
514     A, B, C
515   };
516 </pre></td></tr>
517
518
519 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('templateTemplateParmDecl0')"><a name="templateTemplateParmDecl0Anchor">templateTemplateParmDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTemplateParmDecl.html">TemplateTemplateParmDecl</a>&gt;...</td></tr>
520 <tr><td colspan="4" class="doc" id="templateTemplateParmDecl0"><pre>Matches template template parameter declarations.
521
522 Given
523   template &lt;template &lt;typename&gt; class Z, int N&gt; struct C {};
524 templateTypeParmDecl()
525   matches 'Z', but not 'N'.
526 </pre></td></tr>
527
528
529 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('templateTypeParmDecl0')"><a name="templateTypeParmDecl0Anchor">templateTypeParmDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmDecl.html">TemplateTypeParmDecl</a>&gt;...</td></tr>
530 <tr><td colspan="4" class="doc" id="templateTypeParmDecl0"><pre>Matches template type parameter declarations.
531
532 Given
533   template &lt;typename T, int N&gt; struct C {};
534 templateTypeParmDecl()
535   matches 'T', but not 'N'.
536 </pre></td></tr>
537
538
539 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('translationUnitDecl0')"><a name="translationUnitDecl0Anchor">translationUnitDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TranslationUnitDecl.html">TranslationUnitDecl</a>&gt;...</td></tr>
540 <tr><td colspan="4" class="doc" id="translationUnitDecl0"><pre>Matches the top declaration context.
541
542 Given
543   int X;
544   namespace NS {
545   int Y;
546   }  // namespace NS
547 decl(hasDeclContext(translationUnitDecl()))
548   matches "int X", but not "int Y".
549 </pre></td></tr>
550
551
552 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typeAliasDecl0')"><a name="typeAliasDecl0Anchor">typeAliasDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeAliasDecl.html">TypeAliasDecl</a>&gt;...</td></tr>
553 <tr><td colspan="4" class="doc" id="typeAliasDecl0"><pre>Matches type alias declarations.
554
555 Given
556   typedef int X;
557   using Y = int;
558 typeAliasDecl()
559   matches "using Y = int", but not "typedef int X"
560 </pre></td></tr>
561
562
563 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typeAliasTemplateDecl0')"><a name="typeAliasTemplateDecl0Anchor">typeAliasTemplateDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeAliasTemplateDecl.html">TypeAliasTemplateDecl</a>&gt;...</td></tr>
564 <tr><td colspan="4" class="doc" id="typeAliasTemplateDecl0"><pre>Matches type alias template declarations.
565
566 typeAliasTemplateDecl() matches
567   template &lt;typename T&gt;
568   using Y = X&lt;T&gt;;
569 </pre></td></tr>
570
571
572 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typedefDecl0')"><a name="typedefDecl0Anchor">typedefDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefDecl.html">TypedefDecl</a>&gt;...</td></tr>
573 <tr><td colspan="4" class="doc" id="typedefDecl0"><pre>Matches typedef declarations.
574
575 Given
576   typedef int X;
577   using Y = int;
578 typedefDecl()
579   matches "typedef int X", but not "using Y = int"
580 </pre></td></tr>
581
582
583 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('typedefNameDecl0')"><a name="typedefNameDecl0Anchor">typedefNameDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;...</td></tr>
584 <tr><td colspan="4" class="doc" id="typedefNameDecl0"><pre>Matches typedef name declarations.
585
586 Given
587   typedef int X;
588   using Y = int;
589 typedefNameDecl()
590   matches "typedef int X" and "using Y = int"
591 </pre></td></tr>
592
593
594 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('unresolvedUsingTypenameDecl0')"><a name="unresolvedUsingTypenameDecl0Anchor">unresolvedUsingTypenameDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingTypenameDecl.html">UnresolvedUsingTypenameDecl</a>&gt;...</td></tr>
595 <tr><td colspan="4" class="doc" id="unresolvedUsingTypenameDecl0"><pre>Matches unresolved using value declarations that involve the
596 typename.
597
598 Given
599   template &lt;typename T&gt;
600   struct Base { typedef T Foo; };
601
602   template&lt;typename T&gt;
603   struct S : private Base&lt;T&gt; {
604     using typename Base&lt;T&gt;::Foo;
605   };
606 unresolvedUsingTypenameDecl()
607   matches using Base&lt;T&gt;::Foo </pre></td></tr>
608
609
610 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('unresolvedUsingValueDecl0')"><a name="unresolvedUsingValueDecl0Anchor">unresolvedUsingValueDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedUsingValueDecl.html">UnresolvedUsingValueDecl</a>&gt;...</td></tr>
611 <tr><td colspan="4" class="doc" id="unresolvedUsingValueDecl0"><pre>Matches unresolved using value declarations.
612
613 Given
614   template&lt;typename X&gt;
615   class C : private X {
616     using X::x;
617   };
618 unresolvedUsingValueDecl()
619   matches using X::x </pre></td></tr>
620
621
622 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('usingDecl0')"><a name="usingDecl0Anchor">usingDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingDecl.html">UsingDecl</a>&gt;...</td></tr>
623 <tr><td colspan="4" class="doc" id="usingDecl0"><pre>Matches using declarations.
624
625 Given
626   namespace X { int x; }
627   using X::x;
628 usingDecl()
629   matches using X::x </pre></td></tr>
630
631
632 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('usingDirectiveDecl0')"><a name="usingDirectiveDecl0Anchor">usingDirectiveDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UsingDirectiveDecl.html">UsingDirectiveDecl</a>&gt;...</td></tr>
633 <tr><td colspan="4" class="doc" id="usingDirectiveDecl0"><pre>Matches using namespace declarations.
634
635 Given
636   namespace X { int x; }
637   using namespace X;
638 usingDirectiveDecl()
639   matches using namespace X </pre></td></tr>
640
641
642 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('valueDecl0')"><a name="valueDecl0Anchor">valueDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ValueDecl.html">ValueDecl</a>&gt;...</td></tr>
643 <tr><td colspan="4" class="doc" id="valueDecl0"><pre>Matches any value declaration.
644
645 Example matches A, B, C and F
646   enum X { A, B, C };
647   void F();
648 </pre></td></tr>
649
650
651 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('varDecl0')"><a name="varDecl0Anchor">varDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;...</td></tr>
652 <tr><td colspan="4" class="doc" id="varDecl0"><pre>Matches variable declarations.
653
654 Note: this does not match declarations of member variables, which are
655 "field" declarations in Clang parlance.
656
657 Example matches a
658   int a;
659 </pre></td></tr>
660
661
662 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;</td><td class="name" onclick="toggle('decompositionDecl0')"><a name="decompositionDecl0Anchor">decompositionDecl</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecompositionDecl.html">DecompositionDecl</a>&gt;...</td></tr>
663 <tr><td colspan="4" class="doc" id="decompositionDecl0"><pre>Matches decomposition-declarations.
664
665 Examples matches the declaration node with foo and bar, but not
666 number.
667 (matcher = declStmt(has(decompositionDecl())))
668
669   int number = 42;
670   auto [foo, bar] = std::make_pair{42, 42};
671 </pre></td></tr>
672
673
674 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;</td><td class="name" onclick="toggle('nestedNameSpecifierLoc0')"><a name="nestedNameSpecifierLoc0Anchor">nestedNameSpecifierLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifierLoc.html">NestedNameSpecifierLoc</a>&gt;...</td></tr>
675 <tr><td colspan="4" class="doc" id="nestedNameSpecifierLoc0"><pre>Same as nestedNameSpecifier but matches NestedNameSpecifierLoc.
676 </pre></td></tr>
677
678
679 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;</td><td class="name" onclick="toggle('nestedNameSpecifier0')"><a name="nestedNameSpecifier0Anchor">nestedNameSpecifier</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NestedNameSpecifier.html">NestedNameSpecifier</a>&gt;...</td></tr>
680 <tr><td colspan="4" class="doc" id="nestedNameSpecifier0"><pre>Matches nested name specifiers.
681
682 Given
683   namespace ns {
684     struct A { static void f(); };
685     void A::f() {}
686     void g() { A::f(); }
687   }
688   ns::A a;
689 nestedNameSpecifier()
690   matches "ns::" and both "A::"
691 </pre></td></tr>
692
693
694 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPClause.html">OMPClause</a>&gt;</td><td class="name" onclick="toggle('ompDefaultClause0')"><a name="ompDefaultClause0Anchor">ompDefaultClause</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPDefaultClause.html">OMPDefaultClause</a>&gt;...</td></tr>
695 <tr><td colspan="4" class="doc" id="ompDefaultClause0"><pre>Matches OpenMP ``default`` clause.
696
697 Given
698
699   #pragma omp parallel default(none)
700   #pragma omp parallel default(shared)
701   #pragma omp parallel default(firstprivate)
702   #pragma omp parallel
703
704 ``ompDefaultClause()`` matches ``default(none)``, ``default(shared)``, and
705 ``default(firstprivate)``
706 </pre></td></tr>
707
708
709 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;</td><td class="name" onclick="toggle('qualType0')"><a name="qualType0Anchor">qualType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt;...</td></tr>
710 <tr><td colspan="4" class="doc" id="qualType0"><pre>Matches QualTypes in the clang AST.
711 </pre></td></tr>
712
713
714 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('addrLabelExpr0')"><a name="addrLabelExpr0Anchor">addrLabelExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AddrLabelExpr.html">AddrLabelExpr</a>&gt;...</td></tr>
715 <tr><td colspan="4" class="doc" id="addrLabelExpr0"><pre>Matches address of label statements (GNU extension).
716
717 Given
718   FOO: bar();
719   void *ptr = &amp;&amp;FOO;
720   goto *bar;
721 addrLabelExpr()
722   matches '&amp;&amp;FOO'
723 </pre></td></tr>
724
725
726 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('arraySubscriptExpr0')"><a name="arraySubscriptExpr0Anchor">arraySubscriptExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArraySubscriptExpr.html">ArraySubscriptExpr</a>&gt;...</td></tr>
727 <tr><td colspan="4" class="doc" id="arraySubscriptExpr0"><pre>Matches array subscript expressions.
728
729 Given
730   int i = a[1];
731 arraySubscriptExpr()
732   matches "a[1]"
733 </pre></td></tr>
734
735
736 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('asmStmt0')"><a name="asmStmt0Anchor">asmStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AsmStmt.html">AsmStmt</a>&gt;...</td></tr>
737 <tr><td colspan="4" class="doc" id="asmStmt0"><pre>Matches asm statements.
738
739  int i = 100;
740   __asm("mov al, 2");
741 asmStmt()
742   matches '__asm("mov al, 2")'
743 </pre></td></tr>
744
745
746 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('atomicExpr0')"><a name="atomicExpr0Anchor">atomicExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicExpr.html">AtomicExpr</a>&gt;...</td></tr>
747 <tr><td colspan="4" class="doc" id="atomicExpr0"><pre>Matches atomic builtins.
748 Example matches __atomic_load_n(ptr, 1)
749   void foo() { int *ptr; __atomic_load_n(ptr, 1); }
750 </pre></td></tr>
751
752
753 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('autoreleasePoolStmt0')"><a name="autoreleasePoolStmt0Anchor">autoreleasePoolStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAutoreleasePoolStmt.html">ObjCAutoreleasePoolStmt</a>&gt;...</td></tr>
754 <tr><td colspan="4" class="doc" id="autoreleasePoolStmt0"><pre>Matches an Objective-C autorelease pool statement.
755
756 Given
757   @autoreleasepool {
758     int x = 0;
759   }
760 autoreleasePoolStmt(stmt()) matches the declaration of "x"
761 inside the autorelease pool.
762 </pre></td></tr>
763
764
765 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('binaryConditionalOperator0')"><a name="binaryConditionalOperator0Anchor">binaryConditionalOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryConditionalOperator.html">BinaryConditionalOperator</a>&gt;...</td></tr>
766 <tr><td colspan="4" class="doc" id="binaryConditionalOperator0"><pre>Matches binary conditional operator expressions (GNU extension).
767
768 Example matches a ?: b
769   (a ?: b) + 42;
770 </pre></td></tr>
771
772
773 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('binaryOperator0')"><a name="binaryOperator0Anchor">binaryOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;...</td></tr>
774 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
775
776 Example matches a || b
777   !(a || b)
778 </pre></td></tr>
779
780
781 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('blockExpr0')"><a name="blockExpr0Anchor">blockExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockExpr.html">BlockExpr</a>&gt;...</td></tr>
782 <tr><td colspan="4" class="doc" id="blockExpr0"><pre>Matches a reference to a block.
783
784 Example: matches "^{}":
785   void f() { ^{}(); }
786 </pre></td></tr>
787
788
789 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('breakStmt0')"><a name="breakStmt0Anchor">breakStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BreakStmt.html">BreakStmt</a>&gt;...</td></tr>
790 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.
791
792 Given
793   while (true) { break; }
794 breakStmt()
795   matches 'break'
796 </pre></td></tr>
797
798
799 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cStyleCastExpr0')"><a name="cStyleCastExpr0Anchor">cStyleCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CStyleCastExpr.html">CStyleCastExpr</a>&gt;...</td></tr>
800 <tr><td colspan="4" class="doc" id="cStyleCastExpr0"><pre>Matches a C-style cast expression.
801
802 Example: Matches (int) 2.2f in
803   int i = (int) 2.2f;
804 </pre></td></tr>
805
806
807 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('callExpr0')"><a name="callExpr0Anchor">callExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;...</td></tr>
808 <tr><td colspan="4" class="doc" id="callExpr0"><pre>Matches call expressions.
809
810 Example matches x.y() and y()
811   X x;
812   x.y();
813   y();
814 </pre></td></tr>
815
816
817 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('caseStmt0')"><a name="caseStmt0Anchor">caseStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CaseStmt.html">CaseStmt</a>&gt;...</td></tr>
818 <tr><td colspan="4" class="doc" id="caseStmt0"><pre>Matches case statements inside switch statements.
819
820 Given
821   switch(a) { case 42: break; default: break; }
822 caseStmt()
823   matches 'case 42:'.
824 </pre></td></tr>
825
826
827 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('castExpr0')"><a name="castExpr0Anchor">castExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;...</td></tr>
828 <tr><td colspan="4" class="doc" id="castExpr0"><pre>Matches any cast nodes of Clang's AST.
829
830 Example: castExpr() matches each of the following:
831   (int) 3;
832   const_cast&lt;Expr *&gt;(SubExpr);
833   char c = 0;
834 but does not match
835   int i = (0);
836   int k = 0;
837 </pre></td></tr>
838
839
840 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('characterLiteral0')"><a name="characterLiteral0Anchor">characterLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;...</td></tr>
841 <tr><td colspan="4" class="doc" id="characterLiteral0"><pre>Matches character literals (also matches wchar_t).
842
843 Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
844 though.
845
846 Example matches 'a', L'a'
847   char ch = 'a';
848   wchar_t chw = L'a';
849 </pre></td></tr>
850
851
852 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('chooseExpr0')"><a name="chooseExpr0Anchor">chooseExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ChooseExpr.html">ChooseExpr</a>&gt;...</td></tr>
853 <tr><td colspan="4" class="doc" id="chooseExpr0"><pre>Matches GNU __builtin_choose_expr.
854 </pre></td></tr>
855
856
857 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('compoundLiteralExpr0')"><a name="compoundLiteralExpr0Anchor">compoundLiteralExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundLiteralExpr.html">CompoundLiteralExpr</a>&gt;...</td></tr>
858 <tr><td colspan="4" class="doc" id="compoundLiteralExpr0"><pre>Matches compound (i.e. non-scalar) literals
859
860 Example match: {1}, (1, 2)
861   int array[4] = {1};
862   vector int myvec = (vector int)(1, 2);
863 </pre></td></tr>
864
865
866 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('compoundStmt0')"><a name="compoundStmt0Anchor">compoundStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;...</td></tr>
867 <tr><td colspan="4" class="doc" id="compoundStmt0"><pre>Matches compound statements.
868
869 Example matches '{}' and '{{}}' in 'for (;;) {{}}'
870   for (;;) {{}}
871 </pre></td></tr>
872
873
874 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('conditionalOperator0')"><a name="conditionalOperator0Anchor">conditionalOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConditionalOperator.html">ConditionalOperator</a>&gt;...</td></tr>
875 <tr><td colspan="4" class="doc" id="conditionalOperator0"><pre>Matches conditional operator expressions.
876
877 Example matches a ? b : c
878   (a ? b : c) + 42
879 </pre></td></tr>
880
881
882 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('constantExpr0')"><a name="constantExpr0Anchor">constantExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConstantExpr.html">ConstantExpr</a>&gt;...</td></tr>
883 <tr><td colspan="4" class="doc" id="constantExpr0"><pre>Matches a constant expression wrapper.
884
885 Example matches the constant in the case statement:
886     (matcher = constantExpr())
887   switch (a) {
888   case 37: break;
889   }
890 </pre></td></tr>
891
892
893 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('continueStmt0')"><a name="continueStmt0Anchor">continueStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ContinueStmt.html">ContinueStmt</a>&gt;...</td></tr>
894 <tr><td colspan="4" class="doc" id="continueStmt0"><pre>Matches continue statements.
895
896 Given
897   while (true) { continue; }
898 continueStmt()
899   matches 'continue'
900 </pre></td></tr>
901
902
903 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cudaKernelCallExpr0')"><a name="cudaKernelCallExpr0Anchor">cudaKernelCallExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CUDAKernelCallExpr.html">CUDAKernelCallExpr</a>&gt;...</td></tr>
904 <tr><td colspan="4" class="doc" id="cudaKernelCallExpr0"><pre>Matches CUDA kernel call expression.
905
906 Example matches,
907   kernel&lt;&lt;&lt;i,j&gt;&gt;&gt;();
908 </pre></td></tr>
909
910
911 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxBindTemporaryExpr0')"><a name="cxxBindTemporaryExpr0Anchor">cxxBindTemporaryExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBindTemporaryExpr.html">CXXBindTemporaryExpr</a>&gt;...</td></tr>
912 <tr><td colspan="4" class="doc" id="cxxBindTemporaryExpr0"><pre>Matches nodes where temporaries are created.
913
914 Example matches FunctionTakesString(GetStringByValue())
915     (matcher = cxxBindTemporaryExpr())
916   FunctionTakesString(GetStringByValue());
917   FunctionTakesStringByPointer(GetStringPointer());
918 </pre></td></tr>
919
920
921 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxBoolLiteral0')"><a name="cxxBoolLiteral0Anchor">cxxBoolLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;...</td></tr>
922 <tr><td colspan="4" class="doc" id="cxxBoolLiteral0"><pre>Matches bool literals.
923
924 Example matches true
925   true
926 </pre></td></tr>
927
928
929 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxCatchStmt0')"><a name="cxxCatchStmt0Anchor">cxxCatchStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;...</td></tr>
930 <tr><td colspan="4" class="doc" id="cxxCatchStmt0"><pre>Matches catch statements.
931
932   try {} catch(int i) {}
933 cxxCatchStmt()
934   matches 'catch(int i)'
935 </pre></td></tr>
936
937
938 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxConstCastExpr0')"><a name="cxxConstCastExpr0Anchor">cxxConstCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstCastExpr.html">CXXConstCastExpr</a>&gt;...</td></tr>
939 <tr><td colspan="4" class="doc" id="cxxConstCastExpr0"><pre>Matches a const_cast expression.
940
941 Example: Matches const_cast&lt;int*&gt;(&amp;r) in
942   int n = 42;
943   const int &amp;r(n);
944   int* p = const_cast&lt;int*&gt;(&amp;r);
945 </pre></td></tr>
946
947
948 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxConstructExpr0')"><a name="cxxConstructExpr0Anchor">cxxConstructExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;...</td></tr>
949 <tr><td colspan="4" class="doc" id="cxxConstructExpr0"><pre>Matches constructor call expressions (including implicit ones).
950
951 Example matches string(ptr, n) and ptr within arguments of f
952     (matcher = cxxConstructExpr())
953   void f(const string &amp;a, const string &amp;b);
954   char *ptr;
955   int n;
956   f(string(ptr, n), ptr);
957 </pre></td></tr>
958
959
960 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDefaultArgExpr0')"><a name="cxxDefaultArgExpr0Anchor">cxxDefaultArgExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDefaultArgExpr.html">CXXDefaultArgExpr</a>&gt;...</td></tr>
961 <tr><td colspan="4" class="doc" id="cxxDefaultArgExpr0"><pre>Matches the value of a default argument at the call site.
962
963 Example matches the CXXDefaultArgExpr placeholder inserted for the
964     default value of the second parameter in the call expression f(42)
965     (matcher = cxxDefaultArgExpr())
966   void f(int x, int y = 0);
967   f(42);
968 </pre></td></tr>
969
970
971 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDeleteExpr0')"><a name="cxxDeleteExpr0Anchor">cxxDeleteExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDeleteExpr.html">CXXDeleteExpr</a>&gt;...</td></tr>
972 <tr><td colspan="4" class="doc" id="cxxDeleteExpr0"><pre>Matches delete expressions.
973
974 Given
975   delete X;
976 cxxDeleteExpr()
977   matches 'delete X'.
978 </pre></td></tr>
979
980
981 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDependentScopeMemberExpr0')"><a name="cxxDependentScopeMemberExpr0Anchor">cxxDependentScopeMemberExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;...</td></tr>
982 <tr><td colspan="4" class="doc" id="cxxDependentScopeMemberExpr0"><pre>Matches member expressions where the actual member referenced could not be
983 resolved because the base expression or the member name was dependent.
984
985 Given
986   template &lt;class T&gt; void f() { T t; t.g(); }
987 cxxDependentScopeMemberExpr()
988   matches t.g
989 </pre></td></tr>
990
991
992 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxDynamicCastExpr0')"><a name="cxxDynamicCastExpr0Anchor">cxxDynamicCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDynamicCastExpr.html">CXXDynamicCastExpr</a>&gt;...</td></tr>
993 <tr><td colspan="4" class="doc" id="cxxDynamicCastExpr0"><pre>Matches a dynamic_cast expression.
994
995 Example:
996   cxxDynamicCastExpr()
997 matches
998   dynamic_cast&lt;D*&gt;(&amp;b);
999 in
1000   struct B { virtual ~B() {} }; struct D : B {};
1001   B b;
1002   D* p = dynamic_cast&lt;D*&gt;(&amp;b);
1003 </pre></td></tr>
1004
1005
1006 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxForRangeStmt0')"><a name="cxxForRangeStmt0Anchor">cxxForRangeStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXForRangeStmt.html">CXXForRangeStmt</a>&gt;...</td></tr>
1007 <tr><td colspan="4" class="doc" id="cxxForRangeStmt0"><pre>Matches range-based for statements.
1008
1009 cxxForRangeStmt() matches 'for (auto a : i)'
1010   int i[] =  {1, 2, 3}; for (auto a : i);
1011   for(int j = 0; j &lt; 5; ++j);
1012 </pre></td></tr>
1013
1014
1015 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxFunctionalCastExpr0')"><a name="cxxFunctionalCastExpr0Anchor">cxxFunctionalCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXFunctionalCastExpr.html">CXXFunctionalCastExpr</a>&gt;...</td></tr>
1016 <tr><td colspan="4" class="doc" id="cxxFunctionalCastExpr0"><pre>Matches functional cast expressions
1017
1018 Example: Matches Foo(bar);
1019   Foo f = bar;
1020   Foo g = (Foo) bar;
1021   Foo h = Foo(bar);
1022 </pre></td></tr>
1023
1024
1025 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxMemberCallExpr0')"><a name="cxxMemberCallExpr0Anchor">cxxMemberCallExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMemberCallExpr.html">CXXMemberCallExpr</a>&gt;...</td></tr>
1026 <tr><td colspan="4" class="doc" id="cxxMemberCallExpr0"><pre>Matches member call expressions.
1027
1028 Example matches x.y()
1029   X x;
1030   x.y();
1031 </pre></td></tr>
1032
1033
1034 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxNewExpr0')"><a name="cxxNewExpr0Anchor">cxxNewExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;...</td></tr>
1035 <tr><td colspan="4" class="doc" id="cxxNewExpr0"><pre>Matches new expressions.
1036
1037 Given
1038   new X;
1039 cxxNewExpr()
1040   matches 'new X'.
1041 </pre></td></tr>
1042
1043
1044 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxNoexceptExpr0')"><a name="cxxNoexceptExpr0Anchor">cxxNoexceptExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNoexceptExpr.html">CXXNoexceptExpr</a>&gt;...</td></tr>
1045 <tr><td colspan="4" class="doc" id="cxxNoexceptExpr0"><pre>Matches noexcept expressions.
1046
1047 Given
1048   bool a() noexcept;
1049   bool b() noexcept(true);
1050   bool c() noexcept(false);
1051   bool d() noexcept(noexcept(a()));
1052   bool e = noexcept(b()) || noexcept(c());
1053 cxxNoexceptExpr()
1054   matches `noexcept(a())`, `noexcept(b())` and `noexcept(c())`.
1055   doesn't match the noexcept specifier in the declarations a, b, c or d.
1056 </pre></td></tr>
1057
1058
1059 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxNullPtrLiteralExpr0')"><a name="cxxNullPtrLiteralExpr0Anchor">cxxNullPtrLiteralExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNullPtrLiteralExpr.html">CXXNullPtrLiteralExpr</a>&gt;...</td></tr>
1060 <tr><td colspan="4" class="doc" id="cxxNullPtrLiteralExpr0"><pre>Matches nullptr literal.
1061 </pre></td></tr>
1062
1063
1064 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxOperatorCallExpr0')"><a name="cxxOperatorCallExpr0Anchor">cxxOperatorCallExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;...</td></tr>
1065 <tr><td colspan="4" class="doc" id="cxxOperatorCallExpr0"><pre>Matches overloaded operator calls.
1066
1067 Note that if an operator isn't overloaded, it won't match. Instead, use
1068 binaryOperator matcher.
1069 Currently it does not match operators such as new delete.
1070 FIXME: figure out why these do not match?
1071
1072 Example matches both operator&lt;&lt;((o &lt;&lt; b), c) and operator&lt;&lt;(o, b)
1073     (matcher = cxxOperatorCallExpr())
1074   ostream &amp;operator&lt;&lt; (ostream &amp;out, int i) { };
1075   ostream &amp;o; int b = 1, c = 1;
1076   o &lt;&lt; b &lt;&lt; c;
1077 </pre></td></tr>
1078
1079
1080 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxReinterpretCastExpr0')"><a name="cxxReinterpretCastExpr0Anchor">cxxReinterpretCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXReinterpretCastExpr.html">CXXReinterpretCastExpr</a>&gt;...</td></tr>
1081 <tr><td colspan="4" class="doc" id="cxxReinterpretCastExpr0"><pre>Matches a reinterpret_cast expression.
1082
1083 Either the source expression or the destination type can be matched
1084 using has(), but hasDestinationType() is more specific and can be
1085 more readable.
1086
1087 Example matches reinterpret_cast&lt;char*&gt;(&amp;p) in
1088   void* p = reinterpret_cast&lt;char*&gt;(&amp;p);
1089 </pre></td></tr>
1090
1091
1092 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxStaticCastExpr0')"><a name="cxxStaticCastExpr0Anchor">cxxStaticCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXStaticCastExpr.html">CXXStaticCastExpr</a>&gt;...</td></tr>
1093 <tr><td colspan="4" class="doc" id="cxxStaticCastExpr0"><pre>Matches a C++ static_cast expression.
1094
1095 See also: hasDestinationType
1096 See also: reinterpretCast
1097
1098 Example:
1099   cxxStaticCastExpr()
1100 matches
1101   static_cast&lt;long&gt;(8)
1102 in
1103   long eight(static_cast&lt;long&gt;(8));
1104 </pre></td></tr>
1105
1106
1107 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxStdInitializerListExpr0')"><a name="cxxStdInitializerListExpr0Anchor">cxxStdInitializerListExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXStdInitializerListExpr.html">CXXStdInitializerListExpr</a>&gt;...</td></tr>
1108 <tr><td colspan="4" class="doc" id="cxxStdInitializerListExpr0"><pre>Matches C++ initializer list expressions.
1109
1110 Given
1111   std::vector&lt;int&gt; a({ 1, 2, 3 });
1112   std::vector&lt;int&gt; b = { 4, 5 };
1113   int c[] = { 6, 7 };
1114   std::pair&lt;int, int&gt; d = { 8, 9 };
1115 cxxStdInitializerListExpr()
1116   matches "{ 1, 2, 3 }" and "{ 4, 5 }"
1117 </pre></td></tr>
1118
1119
1120 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxTemporaryObjectExpr0')"><a name="cxxTemporaryObjectExpr0Anchor">cxxTemporaryObjectExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTemporaryObjectExpr.html">CXXTemporaryObjectExpr</a>&gt;...</td></tr>
1121 <tr><td colspan="4" class="doc" id="cxxTemporaryObjectExpr0"><pre>Matches functional cast expressions having N != 1 arguments
1122
1123 Example: Matches Foo(bar, bar)
1124   Foo h = Foo(bar, bar);
1125 </pre></td></tr>
1126
1127
1128 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxThisExpr0')"><a name="cxxThisExpr0Anchor">cxxThisExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXThisExpr.html">CXXThisExpr</a>&gt;...</td></tr>
1129 <tr><td colspan="4" class="doc" id="cxxThisExpr0"><pre>Matches implicit and explicit this expressions.
1130
1131 Example matches the implicit this expression in "return i".
1132     (matcher = cxxThisExpr())
1133 struct foo {
1134   int i;
1135   int f() { return i; }
1136 };
1137 </pre></td></tr>
1138
1139
1140 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxThrowExpr0')"><a name="cxxThrowExpr0Anchor">cxxThrowExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXThrowExpr.html">CXXThrowExpr</a>&gt;...</td></tr>
1141 <tr><td colspan="4" class="doc" id="cxxThrowExpr0"><pre>Matches throw expressions.
1142
1143   try { throw 5; } catch(int i) {}
1144 cxxThrowExpr()
1145   matches 'throw 5'
1146 </pre></td></tr>
1147
1148
1149 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxTryStmt0')"><a name="cxxTryStmt0Anchor">cxxTryStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXTryStmt.html">CXXTryStmt</a>&gt;...</td></tr>
1150 <tr><td colspan="4" class="doc" id="cxxTryStmt0"><pre>Matches try statements.
1151
1152   try {} catch(int i) {}
1153 cxxTryStmt()
1154   matches 'try {}'
1155 </pre></td></tr>
1156
1157
1158 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('cxxUnresolvedConstructExpr0')"><a name="cxxUnresolvedConstructExpr0Anchor">cxxUnresolvedConstructExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXUnresolvedConstructExpr.html">CXXUnresolvedConstructExpr</a>&gt;...</td></tr>
1159 <tr><td colspan="4" class="doc" id="cxxUnresolvedConstructExpr0"><pre>Matches unresolved constructor call expressions.
1160
1161 Example matches T(t) in return statement of f
1162     (matcher = cxxUnresolvedConstructExpr())
1163   template &lt;typename T&gt;
1164   void f(const T&amp; t) { return T(t); }
1165 </pre></td></tr>
1166
1167
1168 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('declRefExpr0')"><a name="declRefExpr0Anchor">declRefExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclRefExpr.html">DeclRefExpr</a>&gt;...</td></tr>
1169 <tr><td colspan="4" class="doc" id="declRefExpr0"><pre>Matches expressions that refer to declarations.
1170
1171 Example matches x in if (x)
1172   bool x;
1173   if (x) {}
1174 </pre></td></tr>
1175
1176
1177 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('declStmt0')"><a name="declStmt0Anchor">declStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;...</td></tr>
1178 <tr><td colspan="4" class="doc" id="declStmt0"><pre>Matches declaration statements.
1179
1180 Given
1181   int a;
1182 declStmt()
1183   matches 'int a'.
1184 </pre></td></tr>
1185
1186
1187 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('defaultStmt0')"><a name="defaultStmt0Anchor">defaultStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DefaultStmt.html">DefaultStmt</a>&gt;...</td></tr>
1188 <tr><td colspan="4" class="doc" id="defaultStmt0"><pre>Matches default statements inside switch statements.
1189
1190 Given
1191   switch(a) { case 42: break; default: break; }
1192 defaultStmt()
1193   matches 'default:'.
1194 </pre></td></tr>
1195
1196
1197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('designatedInitExpr0')"><a name="designatedInitExpr0Anchor">designatedInitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;...</td></tr>
1198 <tr><td colspan="4" class="doc" id="designatedInitExpr0"><pre>Matches C99 designated initializer expressions [C99 6.7.8].
1199
1200 Example: Matches { [2].y = 1.0, [0].x = 1.0 }
1201   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
1202 </pre></td></tr>
1203
1204
1205 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('doStmt0')"><a name="doStmt0Anchor">doStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DoStmt.html">DoStmt</a>&gt;...</td></tr>
1206 <tr><td colspan="4" class="doc" id="doStmt0"><pre>Matches do statements.
1207
1208 Given
1209   do {} while (true);
1210 doStmt()
1211   matches 'do {} while(true)'
1212 </pre></td></tr>
1213
1214
1215 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('explicitCastExpr0')"><a name="explicitCastExpr0Anchor">explicitCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExplicitCastExpr.html">ExplicitCastExpr</a>&gt;...</td></tr>
1216 <tr><td colspan="4" class="doc" id="explicitCastExpr0"><pre>Matches explicit cast expressions.
1217
1218 Matches any cast expression written in user code, whether it be a
1219 C-style cast, a functional-style cast, or a keyword cast.
1220
1221 Does not match implicit conversions.
1222
1223 Note: the name "explicitCast" is chosen to match Clang's terminology, as
1224 Clang uses the term "cast" to apply to implicit conversions as well as to
1225 actual cast expressions.
1226
1227 See also: hasDestinationType.
1228
1229 Example: matches all five of the casts in
1230   int((int)(reinterpret_cast&lt;int&gt;(static_cast&lt;int&gt;(const_cast&lt;int&gt;(42)))))
1231 but does not match the implicit conversion in
1232   long ell = 42;
1233 </pre></td></tr>
1234
1235
1236 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('expr0')"><a name="expr0Anchor">expr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;...</td></tr>
1237 <tr><td colspan="4" class="doc" id="expr0"><pre>Matches expressions.
1238
1239 Example matches x()
1240   void f() { x(); }
1241 </pre></td></tr>
1242
1243
1244 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('exprWithCleanups0')"><a name="exprWithCleanups0Anchor">exprWithCleanups</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ExprWithCleanups.html">ExprWithCleanups</a>&gt;...</td></tr>
1245 <tr><td colspan="4" class="doc" id="exprWithCleanups0"><pre>Matches expressions that introduce cleanups to be run at the end
1246 of the sub-expression's evaluation.
1247
1248 Example matches std::string()
1249   const std::string str = std::string();
1250 </pre></td></tr>
1251
1252
1253 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('fixedPointLiteral0')"><a name="fixedPointLiteral0Anchor">fixedPointLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FixedPointLiteral.html">FixedPointLiteral</a>&gt;...</td></tr>
1254 <tr><td colspan="4" class="doc" id="fixedPointLiteral0"><pre>Matches fixed point literals
1255 </pre></td></tr>
1256
1257
1258 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('floatLiteral0')"><a name="floatLiteral0Anchor">floatLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;...</td></tr>
1259 <tr><td colspan="4" class="doc" id="floatLiteral0"><pre>Matches float literals of all sizes / encodings, e.g.
1260 1.0, 1.0f, 1.0L and 1e10.
1261
1262 Does not match implicit conversions such as
1263   float a = 10;
1264 </pre></td></tr>
1265
1266
1267 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forStmt0')"><a name="forStmt0Anchor">forStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ForStmt.html">ForStmt</a>&gt;...</td></tr>
1268 <tr><td colspan="4" class="doc" id="forStmt0"><pre>Matches for statements.
1269
1270 Example matches 'for (;;) {}'
1271   for (;;) {}
1272   int i[] =  {1, 2, 3}; for (auto a : i);
1273 </pre></td></tr>
1274
1275
1276 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gnuNullExpr0')"><a name="gnuNullExpr0Anchor">gnuNullExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GNUNullExpr.html">GNUNullExpr</a>&gt;...</td></tr>
1277 <tr><td colspan="4" class="doc" id="gnuNullExpr0"><pre>Matches GNU __null expression.
1278 </pre></td></tr>
1279
1280
1281 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('gotoStmt0')"><a name="gotoStmt0Anchor">gotoStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1GotoStmt.html">GotoStmt</a>&gt;...</td></tr>
1282 <tr><td colspan="4" class="doc" id="gotoStmt0"><pre>Matches goto statements.
1283
1284 Given
1285   goto FOO;
1286   FOO: bar();
1287 gotoStmt()
1288   matches 'goto FOO'
1289 </pre></td></tr>
1290
1291
1292 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('ifStmt0')"><a name="ifStmt0Anchor">ifStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IfStmt.html">IfStmt</a>&gt;...</td></tr>
1293 <tr><td colspan="4" class="doc" id="ifStmt0"><pre>Matches if statements.
1294
1295 Example matches 'if (x) {}'
1296   if (x) {}
1297 </pre></td></tr>
1298
1299
1300 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('imaginaryLiteral0')"><a name="imaginaryLiteral0Anchor">imaginaryLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImaginaryLiteral.html">ImaginaryLiteral</a>&gt;...</td></tr>
1301 <tr><td colspan="4" class="doc" id="imaginaryLiteral0"><pre>Matches imaginary literals, which are based on integer and floating
1302 point literals e.g.: 1i, 1.0i
1303 </pre></td></tr>
1304
1305
1306 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('implicitCastExpr0')"><a name="implicitCastExpr0Anchor">implicitCastExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;...</td></tr>
1307 <tr><td colspan="4" class="doc" id="implicitCastExpr0"><pre>Matches the implicit cast nodes of Clang's AST.
1308
1309 This matches many different places, including function call return value
1310 eliding, as well as any type conversions.
1311 </pre></td></tr>
1312
1313
1314 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('implicitValueInitExpr0')"><a name="implicitValueInitExpr0Anchor">implicitValueInitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImplicitValueInitExpr.html">ImplicitValueInitExpr</a>&gt;...</td></tr>
1315 <tr><td colspan="4" class="doc" id="implicitValueInitExpr0"><pre>Matches implicit initializers of init list expressions.
1316
1317 Given
1318   point ptarray[10] = { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 };
1319 implicitValueInitExpr()
1320   matches "[0].y" (implicitly)
1321 </pre></td></tr>
1322
1323
1324 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('initListExpr0')"><a name="initListExpr0Anchor">initListExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;...</td></tr>
1325 <tr><td colspan="4" class="doc" id="initListExpr0"><pre>Matches init list expressions.
1326
1327 Given
1328   int a[] = { 1, 2 };
1329   struct B { int x, y; };
1330   B b = { 5, 6 };
1331 initListExpr()
1332   matches "{ 1, 2 }" and "{ 5, 6 }"
1333 </pre></td></tr>
1334
1335
1336 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('integerLiteral0')"><a name="integerLiteral0Anchor">integerLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;...</td></tr>
1337 <tr><td colspan="4" class="doc" id="integerLiteral0"><pre>Matches integer literals of all sizes / encodings, e.g.
1338 1, 1L, 0x1 and 1U.
1339
1340 Does not match character-encoded integers such as L'a'.
1341 </pre></td></tr>
1342
1343
1344 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('labelStmt0')"><a name="labelStmt0Anchor">labelStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LabelStmt.html">LabelStmt</a>&gt;...</td></tr>
1345 <tr><td colspan="4" class="doc" id="labelStmt0"><pre>Matches label statements.
1346
1347 Given
1348   goto FOO;
1349   FOO: bar();
1350 labelStmt()
1351   matches 'FOO:'
1352 </pre></td></tr>
1353
1354
1355 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('lambdaExpr0')"><a name="lambdaExpr0Anchor">lambdaExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LambdaExpr.html">LambdaExpr</a>&gt;...</td></tr>
1356 <tr><td colspan="4" class="doc" id="lambdaExpr0"><pre>Matches lambda expressions.
1357
1358 Example matches [&amp;](){return 5;}
1359   [&amp;](){return 5;}
1360 </pre></td></tr>
1361
1362
1363 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('materializeTemporaryExpr0')"><a name="materializeTemporaryExpr0Anchor">materializeTemporaryExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MaterializeTemporaryExpr.html">MaterializeTemporaryExpr</a>&gt;...</td></tr>
1364 <tr><td colspan="4" class="doc" id="materializeTemporaryExpr0"><pre>Matches nodes where temporaries are materialized.
1365
1366 Example: Given
1367   struct T {void func();};
1368   T f();
1369   void g(T);
1370 materializeTemporaryExpr() matches 'f()' in these statements
1371   T u(f());
1372   g(f());
1373   f().func();
1374 but does not match
1375   f();
1376 </pre></td></tr>
1377
1378
1379 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('memberExpr0')"><a name="memberExpr0Anchor">memberExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberExpr.html">MemberExpr</a>&gt;...</td></tr>
1380 <tr><td colspan="4" class="doc" id="memberExpr0"><pre>Matches member expressions.
1381
1382 Given
1383   class Y {
1384     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
1385     int a; static int b;
1386   };
1387 memberExpr()
1388   matches this-&gt;x, x, y.x, a, this-&gt;b
1389 </pre></td></tr>
1390
1391
1392 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('nullStmt0')"><a name="nullStmt0Anchor">nullStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1NullStmt.html">NullStmt</a>&gt;...</td></tr>
1393 <tr><td colspan="4" class="doc" id="nullStmt0"><pre>Matches null statements.
1394
1395   foo();;
1396 nullStmt()
1397   matches the second ';'
1398 </pre></td></tr>
1399
1400
1401 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcCatchStmt0')"><a name="objcCatchStmt0Anchor">objcCatchStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtCatchStmt.html">ObjCAtCatchStmt</a>&gt;...</td></tr>
1402 <tr><td colspan="4" class="doc" id="objcCatchStmt0"><pre>Matches Objective-C @catch statements.
1403
1404 Example matches @catch
1405   @try {}
1406   @catch (...) {}
1407 </pre></td></tr>
1408
1409
1410 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcFinallyStmt0')"><a name="objcFinallyStmt0Anchor">objcFinallyStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtFinallyStmt.html">ObjCAtFinallyStmt</a>&gt;...</td></tr>
1411 <tr><td colspan="4" class="doc" id="objcFinallyStmt0"><pre>Matches Objective-C @finally statements.
1412
1413 Example matches @finally
1414   @try {}
1415   @finally {}
1416 </pre></td></tr>
1417
1418
1419 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcIvarRefExpr0')"><a name="objcIvarRefExpr0Anchor">objcIvarRefExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCIvarRefExpr.html">ObjCIvarRefExpr</a>&gt;...</td></tr>
1420 <tr><td colspan="4" class="doc" id="objcIvarRefExpr0"><pre>Matches a reference to an ObjCIvar.
1421
1422 Example: matches "a" in "init" method:
1423 @implementation A {
1424   NSString *a;
1425 }
1426 - (void) init {
1427   a = @"hello";
1428 }
1429 </pre></td></tr>
1430
1431
1432 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcMessageExpr0')"><a name="objcMessageExpr0Anchor">objcMessageExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCMessageExpr.html">ObjCMessageExpr</a>&gt;...</td></tr>
1433 <tr><td colspan="4" class="doc" id="objcMessageExpr0"><pre>Matches ObjectiveC Message invocation expressions.
1434
1435 The innermost message send invokes the "alloc" class method on the
1436 NSString class, while the outermost message send invokes the
1437 "initWithString" instance method on the object returned from
1438 NSString's "alloc". This matcher should match both message sends.
1439   [[NSString alloc] initWithString:@"Hello"]
1440 </pre></td></tr>
1441
1442
1443 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcThrowStmt0')"><a name="objcThrowStmt0Anchor">objcThrowStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtThrowStmt.html">ObjCAtThrowStmt</a>&gt;...</td></tr>
1444 <tr><td colspan="4" class="doc" id="objcThrowStmt0"><pre>Matches Objective-C statements.
1445
1446 Example matches @throw obj;
1447 </pre></td></tr>
1448
1449
1450 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('objcTryStmt0')"><a name="objcTryStmt0Anchor">objcTryStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCAtTryStmt.html">ObjCAtTryStmt</a>&gt;...</td></tr>
1451 <tr><td colspan="4" class="doc" id="objcTryStmt0"><pre>Matches Objective-C @try statements.
1452
1453 Example matches @try
1454   @try {}
1455   @catch (...) {}
1456 </pre></td></tr>
1457
1458
1459 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('ompExecutableDirective0')"><a name="ompExecutableDirective0Anchor">ompExecutableDirective</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OMPExecutableDirective.html">OMPExecutableDirective</a>&gt;...</td></tr>
1460 <tr><td colspan="4" class="doc" id="ompExecutableDirective0"><pre>Matches any ``#pragma omp`` executable directive.
1461
1462 Given
1463
1464   #pragma omp parallel
1465   #pragma omp parallel default(none)
1466   #pragma omp taskyield
1467
1468 ``ompExecutableDirective()`` matches ``omp parallel``,
1469 ``omp parallel default(none)`` and ``omp taskyield``.
1470 </pre></td></tr>
1471
1472
1473 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('opaqueValueExpr0')"><a name="opaqueValueExpr0Anchor">opaqueValueExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1OpaqueValueExpr.html">OpaqueValueExpr</a>&gt;...</td></tr>
1474 <tr><td colspan="4" class="doc" id="opaqueValueExpr0"><pre>Matches opaque value expressions. They are used as helpers
1475 to reference another expressions and can be met
1476 in BinaryConditionalOperators, for example.
1477
1478 Example matches 'a'
1479   (a ?: c) + 42;
1480 </pre></td></tr>
1481
1482
1483 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenExpr0')"><a name="parenExpr0Anchor">parenExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenExpr.html">ParenExpr</a>&gt;...</td></tr>
1484 <tr><td colspan="4" class="doc" id="parenExpr0"><pre>Matches parentheses used in expressions.
1485
1486 Example matches (foo() + 1)
1487   int foo() { return 1; }
1488   int a = (foo() + 1);
1489 </pre></td></tr>
1490
1491
1492 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('parenListExpr0')"><a name="parenListExpr0Anchor">parenListExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenListExpr.html">ParenListExpr</a>&gt;...</td></tr>
1493 <tr><td colspan="4" class="doc" id="parenListExpr0"><pre>Matches paren list expressions.
1494 ParenListExprs don't have a predefined type and are used for late parsing.
1495 In the final AST, they can be met in template declarations.
1496
1497 Given
1498   template&lt;typename T&gt; class X {
1499     void f() {
1500       X x(*this);
1501       int a = 0, b = 1; int i = (a, b);
1502     }
1503   };
1504 parenListExpr() matches "*this" but NOT matches (a, b) because (a, b)
1505 has a predefined type and is a ParenExpr, not a ParenListExpr.
1506 </pre></td></tr>
1507
1508
1509 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('predefinedExpr0')"><a name="predefinedExpr0Anchor">predefinedExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PredefinedExpr.html">PredefinedExpr</a>&gt;...</td></tr>
1510 <tr><td colspan="4" class="doc" id="predefinedExpr0"><pre>Matches predefined identifier expressions [C99 6.4.2.2].
1511
1512 Example: Matches __func__
1513   printf("%s", __func__);
1514 </pre></td></tr>
1515
1516
1517 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('returnStmt0')"><a name="returnStmt0Anchor">returnStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReturnStmt.html">ReturnStmt</a>&gt;...</td></tr>
1518 <tr><td colspan="4" class="doc" id="returnStmt0"><pre>Matches return statements.
1519
1520 Given
1521   return 1;
1522 returnStmt()
1523   matches 'return 1'
1524 </pre></td></tr>
1525
1526
1527 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stmt0')"><a name="stmt0Anchor">stmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;...</td></tr>
1528 <tr><td colspan="4" class="doc" id="stmt0"><pre>Matches statements.
1529
1530 Given
1531   { ++a; }
1532 stmt()
1533   matches both the compound statement '{ ++a; }' and '++a'.
1534 </pre></td></tr>
1535
1536
1537 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stmtExpr0')"><a name="stmtExpr0Anchor">stmtExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;...</td></tr>
1538 <tr><td colspan="4" class="doc" id="stmtExpr0"><pre>Matches statement expression (GNU extension).
1539
1540 Example match: ({ int X = 4; X; })
1541   int C = ({ int X = 4; X; });
1542 </pre></td></tr>
1543
1544
1545 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('stringLiteral0')"><a name="stringLiteral0Anchor">stringLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StringLiteral.html">StringLiteral</a>&gt;...</td></tr>
1546 <tr><td colspan="4" class="doc" id="stringLiteral0"><pre>Matches string literals (also matches wide string literals).
1547
1548 Example matches "abcd", L"abcd"
1549   char *s = "abcd";
1550   wchar_t *ws = L"abcd";
1551 </pre></td></tr>
1552
1553
1554 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('substNonTypeTemplateParmExpr0')"><a name="substNonTypeTemplateParmExpr0Anchor">substNonTypeTemplateParmExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SubstNonTypeTemplateParmExpr.html">SubstNonTypeTemplateParmExpr</a>&gt;...</td></tr>
1555 <tr><td colspan="4" class="doc" id="substNonTypeTemplateParmExpr0"><pre>Matches substitutions of non-type template parameters.
1556
1557 Given
1558   template &lt;int N&gt;
1559   struct A { static const int n = N; };
1560   struct B : public A&lt;42&gt; {};
1561 substNonTypeTemplateParmExpr()
1562   matches "N" in the right-hand side of "static const int n = N;"
1563 </pre></td></tr>
1564
1565
1566 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('switchCase0')"><a name="switchCase0Anchor">switchCase</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchCase.html">SwitchCase</a>&gt;...</td></tr>
1567 <tr><td colspan="4" class="doc" id="switchCase0"><pre>Matches case and default statements inside switch statements.
1568
1569 Given
1570   switch(a) { case 42: break; default: break; }
1571 switchCase()
1572   matches 'case 42:' and 'default:'.
1573 </pre></td></tr>
1574
1575
1576 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('switchStmt0')"><a name="switchStmt0Anchor">switchStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SwitchStmt.html">SwitchStmt</a>&gt;...</td></tr>
1577 <tr><td colspan="4" class="doc" id="switchStmt0"><pre>Matches switch statements.
1578
1579 Given
1580   switch(a) { case 42: break; default: break; }
1581 switchStmt()
1582   matches 'switch(a)'.
1583 </pre></td></tr>
1584
1585
1586 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unaryExprOrTypeTraitExpr0')"><a name="unaryExprOrTypeTraitExpr0Anchor">unaryExprOrTypeTraitExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;...</td></tr>
1587 <tr><td colspan="4" class="doc" id="unaryExprOrTypeTraitExpr0"><pre>Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
1588
1589 Given
1590   Foo x = bar;
1591   int y = sizeof(x) + alignof(x);
1592 unaryExprOrTypeTraitExpr()
1593   matches sizeof(x) and alignof(x)
1594 </pre></td></tr>
1595
1596
1597 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unaryOperator0')"><a name="unaryOperator0Anchor">unaryOperator</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;...</td></tr>
1598 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
1599
1600 Example matches !a
1601   !a || b
1602 </pre></td></tr>
1603
1604
1605 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedLookupExpr0')"><a name="unresolvedLookupExpr0Anchor">unresolvedLookupExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedLookupExpr.html">UnresolvedLookupExpr</a>&gt;...</td></tr>
1606 <tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
1607 but could not be resolved to a specific declaration.
1608
1609 Given
1610   template&lt;typename T&gt;
1611   T foo() { T a; return a; }
1612   template&lt;typename T&gt;
1613   void bar() {
1614     foo&lt;T&gt;();
1615   }
1616 unresolvedLookupExpr()
1617   matches foo&lt;T&gt;() </pre></td></tr>
1618
1619
1620 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedMemberExpr0')"><a name="unresolvedMemberExpr0Anchor">unresolvedMemberExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnresolvedMemberExpr.html">UnresolvedMemberExpr</a>&gt;...</td></tr>
1621 <tr><td colspan="4" class="doc" id="unresolvedMemberExpr0"><pre>Matches unresolved member expressions.
1622
1623 Given
1624   struct X {
1625     template &lt;class T&gt; void f();
1626     void g();
1627   };
1628   template &lt;class T&gt; void h() { X x; x.f&lt;T&gt;(); x.g(); }
1629 unresolvedMemberExpr()
1630   matches x.f&lt;T&gt;
1631 </pre></td></tr>
1632
1633
1634 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('userDefinedLiteral0')"><a name="userDefinedLiteral0Anchor">userDefinedLiteral</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UserDefinedLiteral.html">UserDefinedLiteral</a>&gt;...</td></tr>
1635 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
1636
1637 Example match: "foo"_suffix
1638 </pre></td></tr>
1639
1640
1641 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('whileStmt0')"><a name="whileStmt0Anchor">whileStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;...</td></tr>
1642 <tr><td colspan="4" class="doc" id="whileStmt0"><pre>Matches while statements.
1643
1644 Given
1645   while (true) {}
1646 whileStmt()
1647   matches 'while (true) {}'.
1648 </pre></td></tr>
1649
1650
1651 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;</td><td class="name" onclick="toggle('templateArgumentLoc0')"><a name="templateArgumentLoc0Anchor">templateArgumentLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgumentLoc.html">TemplateArgumentLoc</a>&gt;...</td></tr>
1652 <tr><td colspan="4" class="doc" id="templateArgumentLoc0"><pre>Matches template arguments (with location info).
1653
1654 Given
1655   template &lt;typename T&gt; struct C {};
1656   C&lt;int&gt; c;
1657 templateArgumentLoc()
1658   matches 'int' in C&lt;int&gt;.
1659 </pre></td></tr>
1660
1661
1662 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;</td><td class="name" onclick="toggle('templateArgument0')"><a name="templateArgument0Anchor">templateArgument</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateArgument.html">TemplateArgument</a>&gt;...</td></tr>
1663 <tr><td colspan="4" class="doc" id="templateArgument0"><pre>Matches template arguments.
1664
1665 Given
1666   template &lt;typename T&gt; struct C {};
1667   C&lt;int&gt; c;
1668 templateArgument()
1669   matches 'int' in C&lt;int&gt;.
1670 </pre></td></tr>
1671
1672
1673 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;</td><td class="name" onclick="toggle('templateName0')"><a name="templateName0Anchor">templateName</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateName.html">TemplateName</a>&gt;...</td></tr>
1674 <tr><td colspan="4" class="doc" id="templateName0"><pre>Matches template name.
1675
1676 Given
1677   template &lt;typename T&gt; class X { };
1678   X&lt;int&gt; xi;
1679 templateName()
1680   matches 'X' in X&lt;int&gt;.
1681 </pre></td></tr>
1682
1683
1684 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;</td><td class="name" onclick="toggle('typeLoc0')"><a name="typeLoc0Anchor">typeLoc</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;...</td></tr>
1685 <tr><td colspan="4" class="doc" id="typeLoc0"><pre>Matches TypeLocs in the clang AST.
1686 </pre></td></tr>
1687
1688
1689 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('arrayType0')"><a name="arrayType0Anchor">arrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ArrayType.html">ArrayType</a>&gt;...</td></tr>
1690 <tr><td colspan="4" class="doc" id="arrayType0"><pre>Matches all kinds of arrays.
1691
1692 Given
1693   int a[] = { 2, 3 };
1694   int b[4];
1695   void f() { int c[a[0]]; }
1696 arrayType()
1697   matches "int a[]", "int b[4]" and "int c[a[0]]";
1698 </pre></td></tr>
1699
1700
1701 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('atomicType0')"><a name="atomicType0Anchor">atomicType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AtomicType.html">AtomicType</a>&gt;...</td></tr>
1702 <tr><td colspan="4" class="doc" id="atomicType0"><pre>Matches atomic types.
1703
1704 Given
1705   _Atomic(int) i;
1706 atomicType()
1707   matches "_Atomic(int) i"
1708 </pre></td></tr>
1709
1710
1711 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('autoType0')"><a name="autoType0Anchor">autoType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1AutoType.html">AutoType</a>&gt;...</td></tr>
1712 <tr><td colspan="4" class="doc" id="autoType0"><pre>Matches types nodes representing C++11 auto types.
1713
1714 Given:
1715   auto n = 4;
1716   int v[] = { 2, 3 }
1717   for (auto i : v) { }
1718 autoType()
1719   matches "auto n" and "auto i"
1720 </pre></td></tr>
1721
1722
1723 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('blockPointerType0')"><a name="blockPointerType0Anchor">blockPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockPointerType.html">BlockPointerType</a>&gt;...</td></tr>
1724 <tr><td colspan="4" class="doc" id="blockPointerType0"><pre>Matches block pointer types, i.e. types syntactically represented as
1725 "void (^)(int)".
1726
1727 The pointee is always required to be a FunctionType.
1728 </pre></td></tr>
1729
1730
1731 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('builtinType0')"><a name="builtinType0Anchor">builtinType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BuiltinType.html">BuiltinType</a>&gt;...</td></tr>
1732 <tr><td colspan="4" class="doc" id="builtinType0"><pre>Matches builtin Types.
1733
1734 Given
1735   struct A {};
1736   A a;
1737   int b;
1738   float c;
1739   bool d;
1740 builtinType()
1741   matches "int b", "float c" and "bool d"
1742 </pre></td></tr>
1743
1744
1745 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('complexType0')"><a name="complexType0Anchor">complexType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ComplexType.html">ComplexType</a>&gt;...</td></tr>
1746 <tr><td colspan="4" class="doc" id="complexType0"><pre>Matches C99 complex types.
1747
1748 Given
1749   _Complex float f;
1750 complexType()
1751   matches "_Complex float f"
1752 </pre></td></tr>
1753
1754
1755 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('constantArrayType0')"><a name="constantArrayType0Anchor">constantArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConstantArrayType.html">ConstantArrayType</a>&gt;...</td></tr>
1756 <tr><td colspan="4" class="doc" id="constantArrayType0"><pre>Matches C arrays with a specified constant size.
1757
1758 Given
1759   void() {
1760     int a[2];
1761     int b[] = { 2, 3 };
1762     int c[b[0]];
1763   }
1764 constantArrayType()
1765   matches "int a[2]"
1766 </pre></td></tr>
1767
1768
1769 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('decayedType0')"><a name="decayedType0Anchor">decayedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecayedType.html">DecayedType</a>&gt;...</td></tr>
1770 <tr><td colspan="4" class="doc" id="decayedType0"><pre>Matches decayed type
1771 Example matches i[] in declaration of f.
1772     (matcher = valueDecl(hasType(decayedType(hasDecayedType(pointerType())))))
1773 Example matches i[1].
1774     (matcher = expr(hasType(decayedType(hasDecayedType(pointerType())))))
1775   void f(int i[]) {
1776     i[1] = 0;
1777   }
1778 </pre></td></tr>
1779
1780
1781 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('decltypeType0')"><a name="decltypeType0Anchor">decltypeType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DecltypeType.html">DecltypeType</a>&gt;...</td></tr>
1782 <tr><td colspan="4" class="doc" id="decltypeType0"><pre>Matches types nodes representing C++11 decltype(&lt;expr&gt;) types.
1783
1784 Given:
1785   short i = 1;
1786   int j = 42;
1787   decltype(i + j) result = i + j;
1788 decltypeType()
1789   matches "decltype(i + j)"
1790 </pre></td></tr>
1791
1792
1793 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('deducedTemplateSpecializationType0')"><a name="deducedTemplateSpecializationType0Anchor">deducedTemplateSpecializationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeducedTemplateSpecializationType.html">DeducedTemplateSpecializationType</a>&gt;...</td></tr>
1794 <tr><td colspan="4" class="doc" id="deducedTemplateSpecializationType0"><pre>Matches C++17 deduced template specialization types, e.g. deduced class
1795 template types.
1796
1797 Given
1798   template &lt;typename T&gt;
1799   class C { public: C(T); };
1800
1801   C c(123);
1802 deducedTemplateSpecializationType() matches the type in the declaration
1803 of the variable c.
1804 </pre></td></tr>
1805
1806
1807 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('dependentSizedArrayType0')"><a name="dependentSizedArrayType0Anchor">dependentSizedArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DependentSizedArrayType.html">DependentSizedArrayType</a>&gt;...</td></tr>
1808 <tr><td colspan="4" class="doc" id="dependentSizedArrayType0"><pre>Matches C++ arrays whose size is a value-dependent expression.
1809
1810 Given
1811   template&lt;typename T, int Size&gt;
1812   class array {
1813     T data[Size];
1814   };
1815 dependentSizedArrayType
1816   matches "T data[Size]"
1817 </pre></td></tr>
1818
1819
1820 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('elaboratedType0')"><a name="elaboratedType0Anchor">elaboratedType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ElaboratedType.html">ElaboratedType</a>&gt;...</td></tr>
1821 <tr><td colspan="4" class="doc" id="elaboratedType0"><pre>Matches types specified with an elaborated type keyword or with a
1822 qualified name.
1823
1824 Given
1825   namespace N {
1826     namespace M {
1827       class D {};
1828     }
1829   }
1830   class C {};
1831
1832   class C c;
1833   N::M::D d;
1834
1835 elaboratedType() matches the type of the variable declarations of both
1836 c and d.
1837 </pre></td></tr>
1838
1839
1840 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('enumType0')"><a name="enumType0Anchor">enumType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumType.html">EnumType</a>&gt;...</td></tr>
1841 <tr><td colspan="4" class="doc" id="enumType0"><pre>Matches enum types.
1842
1843 Given
1844   enum C { Green };
1845   enum class S { Red };
1846
1847   C c;
1848   S s;
1849
1850 enumType() matches the type of the variable declarations of both c and
1851 s.
1852 </pre></td></tr>
1853
1854
1855 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('functionProtoType0')"><a name="functionProtoType0Anchor">functionProtoType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionProtoType.html">FunctionProtoType</a>&gt;...</td></tr>
1856 <tr><td colspan="4" class="doc" id="functionProtoType0"><pre>Matches FunctionProtoType nodes.
1857
1858 Given
1859   int (*f)(int);
1860   void g();
1861 functionProtoType()
1862   matches "int (*f)(int)" and the type of "g" in C++ mode.
1863   In C mode, "g" is not matched because it does not contain a prototype.
1864 </pre></td></tr>
1865
1866
1867 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('functionType0')"><a name="functionType0Anchor">functionType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionType.html">FunctionType</a>&gt;...</td></tr>
1868 <tr><td colspan="4" class="doc" id="functionType0"><pre>Matches FunctionType nodes.
1869
1870 Given
1871   int (*f)(int);
1872   void g();
1873 functionType()
1874   matches "int (*f)(int)" and the type of "g".
1875 </pre></td></tr>
1876
1877
1878 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('incompleteArrayType0')"><a name="incompleteArrayType0Anchor">incompleteArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IncompleteArrayType.html">IncompleteArrayType</a>&gt;...</td></tr>
1879 <tr><td colspan="4" class="doc" id="incompleteArrayType0"><pre>Matches C arrays with unspecified size.
1880
1881 Given
1882   int a[] = { 2, 3 };
1883   int b[42];
1884   void f(int c[]) { int d[a[0]]; };
1885 incompleteArrayType()
1886   matches "int a[]" and "int c[]"
1887 </pre></td></tr>
1888
1889
1890 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('injectedClassNameType0')"><a name="injectedClassNameType0Anchor">injectedClassNameType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;...</td></tr>
1891 <tr><td colspan="4" class="doc" id="injectedClassNameType0"><pre>Matches injected class name types.
1892
1893 Example matches S s, but not S&lt;T&gt; s.
1894     (matcher = parmVarDecl(hasType(injectedClassNameType())))
1895   template &lt;typename T&gt; struct S {
1896     void f(S s);
1897     void g(S&lt;T&gt; s);
1898   };
1899 </pre></td></tr>
1900
1901
1902 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('lValueReferenceType0')"><a name="lValueReferenceType0Anchor">lValueReferenceType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1LValueReferenceType.html">LValueReferenceType</a>&gt;...</td></tr>
1903 <tr><td colspan="4" class="doc" id="lValueReferenceType0"><pre>Matches lvalue reference types.
1904
1905 Given:
1906   int *a;
1907   int &amp;b = *a;
1908   int &amp;&amp;c = 1;
1909   auto &amp;d = b;
1910   auto &amp;&amp;e = c;
1911   auto &amp;&amp;f = 2;
1912   int g = 5;
1913
1914 lValueReferenceType() matches the types of b, d, and e. e is
1915 matched since the type is deduced as int&amp; by reference collapsing rules.
1916 </pre></td></tr>
1917
1918
1919 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('memberPointerType0')"><a name="memberPointerType0Anchor">memberPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1MemberPointerType.html">MemberPointerType</a>&gt;...</td></tr>
1920 <tr><td colspan="4" class="doc" id="memberPointerType0"><pre>Matches member pointer types.
1921 Given
1922   struct A { int i; }
1923   A::* ptr = A::i;
1924 memberPointerType()
1925   matches "A::* ptr"
1926 </pre></td></tr>
1927
1928
1929 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('objcObjectPointerType0')"><a name="objcObjectPointerType0Anchor">objcObjectPointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ObjCObjectPointerType.html">ObjCObjectPointerType</a>&gt;...</td></tr>
1930 <tr><td colspan="4" class="doc" id="objcObjectPointerType0"><pre>Matches an Objective-C object pointer type, which is different from
1931 a pointer type, despite being syntactically similar.
1932
1933 Given
1934   int *a;
1935
1936   @interface Foo
1937   @end
1938   Foo *f;
1939 pointerType()
1940   matches "Foo *f", but does not match "int *a".
1941 </pre></td></tr>
1942
1943
1944 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('parenType0')"><a name="parenType0Anchor">parenType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ParenType.html">ParenType</a>&gt;...</td></tr>
1945 <tr><td colspan="4" class="doc" id="parenType0"><pre>Matches ParenType nodes.
1946
1947 Given
1948   int (*ptr_to_array)[4];
1949   int *array_of_ptrs[4];
1950
1951 varDecl(hasType(pointsTo(parenType()))) matches ptr_to_array but not
1952 array_of_ptrs.
1953 </pre></td></tr>
1954
1955
1956 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('pointerType0')"><a name="pointerType0Anchor">pointerType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1PointerType.html">PointerType</a>&gt;...</td></tr>
1957 <tr><td colspan="4" class="doc" id="pointerType0"><pre>Matches pointer types, but does not match Objective-C object pointer
1958 types.
1959
1960 Given
1961   int *a;
1962   int &amp;b = *a;
1963   int c = 5;
1964
1965   @interface Foo
1966   @end
1967   Foo *f;
1968 pointerType()
1969   matches "int *a", but does not match "Foo *f".
1970 </pre></td></tr>
1971
1972
1973 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('rValueReferenceType0')"><a name="rValueReferenceType0Anchor">rValueReferenceType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RValueReferenceType.html">RValueReferenceType</a>&gt;...</td></tr>
1974 <tr><td colspan="4" class="doc" id="rValueReferenceType0"><pre>Matches rvalue reference types.
1975
1976 Given:
1977   int *a;
1978   int &amp;b = *a;
1979   int &amp;&amp;c = 1;
1980   auto &amp;d = b;
1981   auto &amp;&amp;e = c;
1982   auto &amp;&amp;f = 2;
1983   int g = 5;
1984
1985 rValueReferenceType() matches the types of c and f. e is not
1986 matched as it is deduced to int&amp; by reference collapsing rules.
1987 </pre></td></tr>
1988
1989
1990 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('recordType0')"><a name="recordType0Anchor">recordType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1RecordType.html">RecordType</a>&gt;...</td></tr>
1991 <tr><td colspan="4" class="doc" id="recordType0"><pre>Matches record types (e.g. structs, classes).
1992
1993 Given
1994   class C {};
1995   struct S {};
1996
1997   C c;
1998   S s;
1999
2000 recordType() matches the type of the variable declarations of both c
2001 and s.
2002 </pre></td></tr>
2003
2004
2005 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('referenceType0')"><a name="referenceType0Anchor">referenceType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ReferenceType.html">ReferenceType</a>&gt;...</td></tr>
2006 <tr><td colspan="4" class="doc" id="referenceType0"><pre>Matches both lvalue and rvalue reference types.
2007
2008 Given
2009   int *a;
2010   int &amp;b = *a;
2011   int &amp;&amp;c = 1;
2012   auto &amp;d = b;
2013   auto &amp;&amp;e = c;
2014   auto &amp;&amp;f = 2;
2015   int g = 5;
2016
2017 referenceType() matches the types of b, c, d, e, and f.
2018 </pre></td></tr>
2019
2020
2021 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('substTemplateTypeParmType0')"><a name="substTemplateTypeParmType0Anchor">substTemplateTypeParmType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1SubstTemplateTypeParmType.html">SubstTemplateTypeParmType</a>&gt;...</td></tr>
2022 <tr><td colspan="4" class="doc" id="substTemplateTypeParmType0"><pre>Matches types that represent the result of substituting a type for a
2023 template type parameter.
2024
2025 Given
2026   template &lt;typename T&gt;
2027   void F(T t) {
2028     int i = 1 + t;
2029   }
2030
2031 substTemplateTypeParmType() matches the type of 't' but not '1'
2032 </pre></td></tr>
2033
2034
2035 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('tagType0')"><a name="tagType0Anchor">tagType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TagType.html">TagType</a>&gt;...</td></tr>
2036 <tr><td colspan="4" class="doc" id="tagType0"><pre>Matches tag types (record and enum types).
2037
2038 Given
2039   enum E {};
2040   class C {};
2041
2042   E e;
2043   C c;
2044
2045 tagType() matches the type of the variable declarations of both e
2046 and c.
2047 </pre></td></tr>
2048
2049
2050 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('templateSpecializationType0')"><a name="templateSpecializationType0Anchor">templateSpecializationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateSpecializationType.html">TemplateSpecializationType</a>&gt;...</td></tr>
2051 <tr><td colspan="4" class="doc" id="templateSpecializationType0"><pre>Matches template specialization types.
2052
2053 Given
2054   template &lt;typename T&gt;
2055   class C { };
2056
2057   template class C&lt;int&gt;;  // A
2058   C&lt;char&gt; var;            // B
2059
2060 templateSpecializationType() matches the type of the explicit
2061 instantiation in A and the type of the variable declaration in B.
2062 </pre></td></tr>
2063
2064
2065 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('templateTypeParmType0')"><a name="templateTypeParmType0Anchor">templateTypeParmType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TemplateTypeParmType.html">TemplateTypeParmType</a>&gt;...</td></tr>
2066 <tr><td colspan="4" class="doc" id="templateTypeParmType0"><pre>Matches template type parameter types.
2067
2068 Example matches T, but not int.
2069     (matcher = templateTypeParmType())
2070   template &lt;typename T&gt; void f(int i);
2071 </pre></td></tr>
2072
2073
2074 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('type0')"><a name="type0Anchor">type</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;...</td></tr>
2075 <tr><td colspan="4" class="doc" id="type0"><pre>Matches Types in the clang AST.
2076 </pre></td></tr>
2077
2078
2079 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('typedefType0')"><a name="typedefType0Anchor">typedefType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefType.html">TypedefType</a>&gt;...</td></tr>
2080 <tr><td colspan="4" class="doc" id="typedefType0"><pre>Matches typedef types.
2081
2082 Given
2083   typedef int X;
2084 typedefType()
2085   matches "typedef int X"
2086 </pre></td></tr>
2087
2088
2089 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('unaryTransformType0')"><a name="unaryTransformType0Anchor">unaryTransformType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryTransformType.html">UnaryTransformType</a>&gt;...</td></tr>
2090 <tr><td colspan="4" class="doc" id="unaryTransformType0"><pre>Matches types nodes representing unary type transformations.
2091
2092 Given:
2093   typedef __underlying_type(T) type;
2094 unaryTransformType()
2095   matches "__underlying_type(T)"
2096 </pre></td></tr>
2097
2098
2099 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Type.html">Type</a>&gt;</td><td class="name" onclick="toggle('variableArrayType0')"><a name="variableArrayType0Anchor">variableArrayType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VariableArrayType.html">VariableArrayType</a>&gt;...</td></tr>
2100 <tr><td colspan="4" class="doc" id="variableArrayType0"><pre>Matches C arrays with a specified size that is not an
2101 integer-constant-expression.
2102
2103 Given
2104   void f() {
2105     int a[] = { 2, 3 }
2106     int b[42];
2107     int c[a[0]];
2108   }
2109 variableArrayType()
2110   matches "int c[a[0]]"
2111 </pre></td></tr>
2112
2113 <!--END_DECL_MATCHERS -->
2114 </table>
2115
2116 <!-- ======================================================================= -->
2117 <h2 id="narrowing-matchers">Narrowing Matchers</h2>
2118 <!-- ======================================================================= -->
2119
2120 <p>Narrowing matchers match certain attributes on the current node, thus
2121 narrowing down the set of nodes of the current type to match on.</p>
2122
2123 <p>There are special logical narrowing matchers (allOf, anyOf, anything and unless)
2124 which allow users to create more powerful match expressions.</p>
2125
2126 <table>
2127 <tr style="text-align:left"><th>Return type</th><th>Name</th><th>Parameters</th></tr>
2128 <!-- START_NARROWING_MATCHERS -->
2129
2130 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('allOf0')"><a name="allOf0Anchor">allOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
2131 <tr><td colspan="4" class="doc" id="allOf0"><pre>Matches if all given matchers match.
2132
2133 Usable as: Any Matcher
2134 </pre></td></tr>
2135
2136
2137 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anyOf0')"><a name="anyOf0Anchor">anyOf</a></td><td>Matcher&lt;*&gt;, ..., Matcher&lt;*&gt;</td></tr>
2138 <tr><td colspan="4" class="doc" id="anyOf0"><pre>Matches if any of the given matchers matches.
2139
2140 Usable as: Any Matcher
2141 </pre></td></tr>
2142
2143
2144 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('anything0')"><a name="anything0Anchor">anything</a></td><td></td></tr>
2145 <tr><td colspan="4" class="doc" id="anything0"><pre>Matches any node.
2146
2147 Useful when another matcher requires a child matcher, but there's no
2148 additional constraint. This will often be used with an explicit conversion
2149 to an internal::Matcher&lt;&gt; type such as TypeMatcher.
2150
2151 Example: DeclarationMatcher(anything()) matches all declarations, e.g.,
2152 "int* p" and "void f()" in
2153   int* p;
2154   void f();
2155
2156 Usable as: Any Matcher
2157 </pre></td></tr>
2158
2159
2160 <tr><td>Matcher&lt;*&gt;</td><td class="name" onclick="toggle('unless0')"><a name="unless0Anchor">unless</a></td><td>Matcher&lt;*&gt;</td></tr>
2161 <tr><td colspan="4" class="doc" id="unless0"><pre>Matches if the provided matcher does not match.
2162
2163 Example matches Y (matcher = cxxRecordDecl(unless(hasName("X"))))
2164   class X {};
2165   class Y {};
2166
2167 Usable as: Any Matcher
2168 </pre></td></tr>
2169
2170
2171 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasAnyOperatorName0')"><a name="hasAnyOperatorName0Anchor">hasAnyOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
2172 <tr><td colspan="4" class="doc" id="hasAnyOperatorName0"><pre>Matches operator expressions (binary or unary) that have any of the
2173 specified names.
2174
2175    hasAnyOperatorName("+", "-")
2176  Is equivalent to
2177    anyOf(hasOperatorName("+"), hasOperatorName("-"))
2178 </pre></td></tr>
2179
2180
2181 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('hasOperatorName0')"><a name="hasOperatorName0Anchor">hasOperatorName</a></td><td>std::string Name</td></tr>
2182 <tr><td colspan="4" class="doc" id="hasOperatorName0"><pre>Matches the operator Name of operator expressions (binary or
2183 unary).
2184
2185 Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
2186   !(a || b)
2187 </pre></td></tr>
2188
2189
2190 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isAssignmentOperator0')"><a name="isAssignmentOperator0Anchor">isAssignmentOperator</a></td><td></td></tr>
2191 <tr><td colspan="4" class="doc" id="isAssignmentOperator0"><pre>Matches all kinds of assignment operators.
2192
2193 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
2194   if (a == b)
2195     a += b;
2196
2197 Example 2: matches s1 = s2
2198            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
2199   struct S { S&amp; operator=(const S&amp;); };
2200   void x() { S s1, s2; s1 = s2; }
2201 </pre></td></tr>
2202
2203
2204 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BinaryOperator.html">BinaryOperator</a>&gt;</td><td class="name" onclick="toggle('isComparisonOperator0')"><a name="isComparisonOperator0Anchor">isComparisonOperator</a></td><td></td></tr>
2205 <tr><td colspan="4" class="doc" id="isComparisonOperator0"><pre>Matches comparison operators.
2206
2207 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
2208   if (a == b)
2209     a += b;
2210
2211 Example 2: matches s1 &lt; s2
2212            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
2213   struct S { bool operator&lt;(const S&amp; other); };
2214   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
2215 </pre></td></tr>
2216
2217
2218 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isPrivate1')"><a name="isPrivate1Anchor">isPrivate</a></td><td></td></tr>
2219 <tr><td colspan="4" class="doc" id="isPrivate1"><pre>Matches private C++ declarations and C++ base specifers that specify private
2220 inheritance.
2221
2222 Examples:
2223   class C {
2224   public:    int a;
2225   protected: int b;
2226   private:   int c; // fieldDecl(isPrivate()) matches 'c'
2227   };
2228
2229   struct Base {};
2230   struct Derived1 : private Base {}; // matches 'Base'
2231   class Derived2 : Base {}; // matches 'Base'
2232 </pre></td></tr>
2233
2234
2235 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isProtected1')"><a name="isProtected1Anchor">isProtected</a></td><td></td></tr>
2236 <tr><td colspan="4" class="doc" id="isProtected1"><pre>Matches protected C++ declarations and C++ base specifers that specify
2237 protected inheritance.
2238
2239 Examples:
2240   class C {
2241   public:    int a;
2242   protected: int b; // fieldDecl(isProtected()) matches 'b'
2243   private:   int c;
2244   };
2245
2246   class Base {};
2247   class Derived : protected Base {}; // matches 'Base'
2248 </pre></td></tr>
2249
2250
2251 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isPublic1')"><a name="isPublic1Anchor">isPublic</a></td><td></td></tr>
2252 <tr><td colspan="4" class="doc" id="isPublic1"><pre>Matches public C++ declarations and C++ base specifers that specify public
2253 inheritance.
2254
2255 Examples:
2256   class C {
2257   public:    int a; // fieldDecl(isPublic()) matches 'a'
2258   protected: int b;
2259   private:   int c;
2260   };
2261
2262   class Base {};
2263   class Derived1 : public Base {}; // matches 'Base'
2264   struct Derived2 : Base {}; // matches 'Base'
2265 </pre></td></tr>
2266
2267
2268 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;</td><td class="name" onclick="toggle('isVirtual1')"><a name="isVirtual1Anchor">isVirtual</a></td><td></td></tr>
2269 <tr><td colspan="4" class="doc" id="isVirtual1"><pre>Matches declarations of virtual methods and C++ base specifers that specify
2270 virtual inheritance.
2271
2272 Example:
2273   class A {
2274    public:
2275     virtual void x(); // matches x
2276   };
2277
2278 Example:
2279   class Base {};
2280   class DirectlyDerived : virtual Base {}; // matches Base
2281   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
2282
2283 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
2284 </pre></td></tr>
2285
2286
2287 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals5')"><a name="equals5Anchor">equals</a></td><td>bool Value</td></tr>
2288 <tr><td colspan="4" class="doc" id="equals5"><pre></pre></td></tr>
2289
2290
2291 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals2')"><a name="equals2Anchor">equals</a></td><td>const ValueT  Value</td></tr>
2292 <tr><td colspan="4" class="doc" id="equals2"><pre>Matches literals that are equal to the given value of type ValueT.
2293
2294 Given
2295   f('false, 3.14, 42);
2296 characterLiteral(equals(0))
2297   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
2298   match false
2299 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
2300   match 3.14
2301 integerLiteral(equals(42))
2302   matches 42
2303
2304 Note that you cannot directly match a negative numeric literal because the
2305 minus sign is not part of the literal: It is a unary operator whose operand
2306 is the positive numeric literal. Instead, you must use a unaryOperator()
2307 matcher to match the minus sign:
2308
2309 unaryOperator(hasOperatorName("-"),
2310               hasUnaryOperand(integerLiteral(equals(13))))
2311
2312 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
2313            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
2314 </pre></td></tr>
2315
2316
2317 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals11')"><a name="equals11Anchor">equals</a></td><td>double Value</td></tr>
2318 <tr><td colspan="4" class="doc" id="equals11"><pre></pre></td></tr>
2319
2320
2321 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;</td><td class="name" onclick="toggle('equals8')"><a name="equals8Anchor">equals</a></td><td>unsigned Value</td></tr>
2322 <tr><td colspan="4" class="doc" id="equals8"><pre></pre></td></tr>
2323
2324
2325 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCatchStmt.html">CXXCatchStmt</a>&gt;</td><td class="name" onclick="toggle('isCatchAll0')"><a name="isCatchAll0Anchor">isCatchAll</a></td><td></td></tr>
2326 <tr><td colspan="4" class="doc" id="isCatchAll0"><pre>Matches a C++ catch statement that has a catch-all handler.
2327
2328 Given
2329   try {
2330     // ...
2331   } catch (int) {
2332     // ...
2333   } catch (...) {
2334     // ...
2335   }
2336 cxxCatchStmt(isCatchAll()) matches catch(...) but not catch(int).
2337 </pre></td></tr>
2338
2339
2340 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs1')"><a name="argumentCountIs1Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
2341 <tr><td colspan="4" class="doc" id="argumentCountIs1"><pre>Checks that a call expression or a constructor call expression has
2342 a specific number of arguments (including absent default arguments).
2343
2344 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2345   void f(int x, int y);
2346   f(0, 0);
2347 </pre></td></tr>
2348
2349
2350 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('isListInitialization0')"><a name="isListInitialization0Anchor">isListInitialization</a></td><td></td></tr>
2351 <tr><td colspan="4" class="doc" id="isListInitialization0"><pre>Matches a constructor call expression which uses list initialization.
2352 </pre></td></tr>
2353
2354
2355 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructExpr.html">CXXConstructExpr</a>&gt;</td><td class="name" onclick="toggle('requiresZeroInitialization0')"><a name="requiresZeroInitialization0Anchor">requiresZeroInitialization</a></td><td></td></tr>
2356 <tr><td colspan="4" class="doc" id="requiresZeroInitialization0"><pre>Matches a constructor call expression which requires
2357 zero initialization.
2358
2359 Given
2360 void foo() {
2361   struct point { double x; double y; };
2362   point pt[2] = { { 1.0, 2.0 } };
2363 }
2364 initListExpr(has(cxxConstructExpr(requiresZeroInitialization()))
2365 will match the implicit array filler for pt[1].
2366 </pre></td></tr>
2367
2368
2369 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isCopyConstructor0')"><a name="isCopyConstructor0Anchor">isCopyConstructor</a></td><td></td></tr>
2370 <tr><td colspan="4" class="doc" id="isCopyConstructor0"><pre>Matches constructor declarations that are copy constructors.
2371
2372 Given
2373   struct S {
2374     S(); // #1
2375     S(const S &amp;); // #2
2376     S(S &amp;&amp;); // #3
2377   };
2378 cxxConstructorDecl(isCopyConstructor()) will match #2, but not #1 or #3.
2379 </pre></td></tr>
2380
2381
2382 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isDefaultConstructor0')"><a name="isDefaultConstructor0Anchor">isDefaultConstructor</a></td><td></td></tr>
2383 <tr><td colspan="4" class="doc" id="isDefaultConstructor0"><pre>Matches constructor declarations that are default constructors.
2384
2385 Given
2386   struct S {
2387     S(); // #1
2388     S(const S &amp;); // #2
2389     S(S &amp;&amp;); // #3
2390   };
2391 cxxConstructorDecl(isDefaultConstructor()) will match #1, but not #2 or #3.
2392 </pre></td></tr>
2393
2394
2395 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isDelegatingConstructor0')"><a name="isDelegatingConstructor0Anchor">isDelegatingConstructor</a></td><td></td></tr>
2396 <tr><td colspan="4" class="doc" id="isDelegatingConstructor0"><pre>Matches constructors that delegate to another constructor.
2397
2398 Given
2399   struct S {
2400     S(); // #1
2401     S(int) {} // #2
2402     S(S &amp;&amp;) : S() {} // #3
2403   };
2404   S::S() : S(0) {} // #4
2405 cxxConstructorDecl(isDelegatingConstructor()) will match #3 and #4, but not
2406 #1 or #2.
2407 </pre></td></tr>
2408
2409
2410 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit0')"><a name="isExplicit0Anchor">isExplicit</a></td><td></td></tr>
2411 <tr><td colspan="4" class="doc" id="isExplicit0"><pre>Matches constructor, conversion function, and deduction guide declarations
2412 that have an explicit specifier if this explicit specifier is resolved to
2413 true.
2414
2415 Given
2416   template&lt;bool b&gt;
2417   struct S {
2418     S(int); // #1
2419     explicit S(double); // #2
2420     operator int(); // #3
2421     explicit operator bool(); // #4
2422     explicit(false) S(bool) // # 7
2423     explicit(true) S(char) // # 8
2424     explicit(b) S(S) // # 9
2425   };
2426   S(int) -&gt; S&lt;true&gt; // #5
2427   explicit S(double) -&gt; S&lt;false&gt; // #6
2428 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2429 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2430 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2431 </pre></td></tr>
2432
2433
2434 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConstructorDecl.html">CXXConstructorDecl</a>&gt;</td><td class="name" onclick="toggle('isMoveConstructor0')"><a name="isMoveConstructor0Anchor">isMoveConstructor</a></td><td></td></tr>
2435 <tr><td colspan="4" class="doc" id="isMoveConstructor0"><pre>Matches constructor declarations that are move constructors.
2436
2437 Given
2438   struct S {
2439     S(); // #1
2440     S(const S &amp;); // #2
2441     S(S &amp;&amp;); // #3
2442   };
2443 cxxConstructorDecl(isMoveConstructor()) will match #3, but not #1 or #2.
2444 </pre></td></tr>
2445
2446
2447 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXConversionDecl.html">CXXConversionDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit1')"><a name="isExplicit1Anchor">isExplicit</a></td><td></td></tr>
2448 <tr><td colspan="4" class="doc" id="isExplicit1"><pre>Matches constructor, conversion function, and deduction guide declarations
2449 that have an explicit specifier if this explicit specifier is resolved to
2450 true.
2451
2452 Given
2453   template&lt;bool b&gt;
2454   struct S {
2455     S(int); // #1
2456     explicit S(double); // #2
2457     operator int(); // #3
2458     explicit operator bool(); // #4
2459     explicit(false) S(bool) // # 7
2460     explicit(true) S(char) // # 8
2461     explicit(b) S(S) // # 9
2462   };
2463   S(int) -&gt; S&lt;true&gt; // #5
2464   explicit S(double) -&gt; S&lt;false&gt; // #6
2465 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2466 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2467 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2468 </pre></td></tr>
2469
2470
2471 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isBaseInitializer0')"><a name="isBaseInitializer0Anchor">isBaseInitializer</a></td><td></td></tr>
2472 <tr><td colspan="4" class="doc" id="isBaseInitializer0"><pre>Matches a constructor initializer if it is initializing a base, as
2473 opposed to a member.
2474
2475 Given
2476   struct B {};
2477   struct D : B {
2478     int I;
2479     D(int i) : I(i) {}
2480   };
2481   struct E : B {
2482     E() : B() {}
2483   };
2484 cxxConstructorDecl(hasAnyConstructorInitializer(isBaseInitializer()))
2485   will match E(), but not match D(int).
2486 </pre></td></tr>
2487
2488
2489 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isMemberInitializer0')"><a name="isMemberInitializer0Anchor">isMemberInitializer</a></td><td></td></tr>
2490 <tr><td colspan="4" class="doc" id="isMemberInitializer0"><pre>Matches a constructor initializer if it is initializing a member, as
2491 opposed to a base.
2492
2493 Given
2494   struct B {};
2495   struct D : B {
2496     int I;
2497     D(int i) : I(i) {}
2498   };
2499   struct E : B {
2500     E() : B() {}
2501   };
2502 cxxConstructorDecl(hasAnyConstructorInitializer(isMemberInitializer()))
2503   will match D(int), but not match E().
2504 </pre></td></tr>
2505
2506
2507 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXCtorInitializer.html">CXXCtorInitializer</a>&gt;</td><td class="name" onclick="toggle('isWritten0')"><a name="isWritten0Anchor">isWritten</a></td><td></td></tr>
2508 <tr><td colspan="4" class="doc" id="isWritten0"><pre>Matches a constructor initializer if it is explicitly written in
2509 code (as opposed to implicitly added by the compiler).
2510
2511 Given
2512   struct Foo {
2513     Foo() { }
2514     Foo(int) : foo_("A") { }
2515     string foo_;
2516   };
2517 cxxConstructorDecl(hasAnyConstructorInitializer(isWritten()))
2518   will match Foo(int), but not Foo()
2519 </pre></td></tr>
2520
2521
2522 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDeductionGuideDecl.html">CXXDeductionGuideDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicit2')"><a name="isExplicit2Anchor">isExplicit</a></td><td></td></tr>
2523 <tr><td colspan="4" class="doc" id="isExplicit2"><pre>Matches constructor, conversion function, and deduction guide declarations
2524 that have an explicit specifier if this explicit specifier is resolved to
2525 true.
2526
2527 Given
2528   template&lt;bool b&gt;
2529   struct S {
2530     S(int); // #1
2531     explicit S(double); // #2
2532     operator int(); // #3
2533     explicit operator bool(); // #4
2534     explicit(false) S(bool) // # 7
2535     explicit(true) S(char) // # 8
2536     explicit(b) S(S) // # 9
2537   };
2538   S(int) -&gt; S&lt;true&gt; // #5
2539   explicit S(double) -&gt; S&lt;false&gt; // #6
2540 cxxConstructorDecl(isExplicit()) will match #2 and #8, but not #1, #7 or #9.
2541 cxxConversionDecl(isExplicit()) will match #4, but not #3.
2542 cxxDeductionGuideDecl(isExplicit()) will match #6, but not #5.
2543 </pre></td></tr>
2544
2545
2546 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXDependentScopeMemberExpr.html">CXXDependentScopeMemberExpr</a>&gt;</td><td class="name" onclick="toggle('isArrow2')"><a name="isArrow2Anchor">isArrow</a></td><td></td></tr>
2547 <tr><td colspan="4" class="doc" id="isArrow2"><pre>Matches member expressions that are called with '-&gt;' as opposed
2548 to '.'.
2549
2550 Member calls on the implicit this pointer match as called with '-&gt;'.
2551
2552 Given
2553   class Y {
2554     void x() { this-&gt;x(); x(); Y y; y.x(); a; this-&gt;b; Y::b; }
2555     template &lt;class T&gt; void f() { this-&gt;f&lt;T&gt;(); f&lt;T&gt;(); }
2556     int a;
2557     static int b;
2558   };
2559   template &lt;class T&gt;
2560   class Z {
2561     void x() { this-&gt;m; }
2562   };
2563 memberExpr(isArrow())
2564   matches this-&gt;x, x, y.x, a, this-&gt;b
2565 cxxDependentScopeMemberExpr(isArrow())
2566   matches this-&gt;m
2567 unresolvedMemberExpr(isArrow())
2568   matches this-&gt;f&lt;T&gt;, f&lt;T&gt;
2569 </pre></td></tr>
2570
2571
2572 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isConst0')"><a name="isConst0Anchor">isConst</a></td><td></td></tr>
2573 <tr><td colspan="4" class="doc" id="isConst0"><pre>Matches if the given method declaration is const.
2574
2575 Given
2576 struct A {
2577   void foo() const;
2578   void bar();
2579 };
2580
2581 cxxMethodDecl(isConst()) matches A::foo() but not A::bar()
2582 </pre></td></tr>
2583
2584
2585 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isCopyAssignmentOperator0')"><a name="isCopyAssignmentOperator0Anchor">isCopyAssignmentOperator</a></td><td></td></tr>
2586 <tr><td colspan="4" class="doc" id="isCopyAssignmentOperator0"><pre>Matches if the given method declaration declares a copy assignment
2587 operator.
2588
2589 Given
2590 struct A {
2591   A &amp;operator=(const A &amp;);
2592   A &amp;operator=(A &amp;&amp;);
2593 };
2594
2595 cxxMethodDecl(isCopyAssignmentOperator()) matches the first method but not
2596 the second one.
2597 </pre></td></tr>
2598
2599
2600 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isFinal1')"><a name="isFinal1Anchor">isFinal</a></td><td></td></tr>
2601 <tr><td colspan="4" class="doc" id="isFinal1"><pre>Matches if the given method or class declaration is final.
2602
2603 Given:
2604   class A final {};
2605
2606   struct B {
2607     virtual void f();
2608   };
2609
2610   struct C : B {
2611     void f() final;
2612   };
2613 matches A and C::f, but not B, C, or B::f
2614 </pre></td></tr>
2615
2616
2617 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isMoveAssignmentOperator0')"><a name="isMoveAssignmentOperator0Anchor">isMoveAssignmentOperator</a></td><td></td></tr>
2618 <tr><td colspan="4" class="doc" id="isMoveAssignmentOperator0"><pre>Matches if the given method declaration declares a move assignment
2619 operator.
2620
2621 Given
2622 struct A {
2623   A &amp;operator=(const A &amp;);
2624   A &amp;operator=(A &amp;&amp;);
2625 };
2626
2627 cxxMethodDecl(isMoveAssignmentOperator()) matches the second method but not
2628 the first one.
2629 </pre></td></tr>
2630
2631
2632 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isOverride0')"><a name="isOverride0Anchor">isOverride</a></td><td></td></tr>
2633 <tr><td colspan="4" class="doc" id="isOverride0"><pre>Matches if the given method declaration overrides another method.
2634
2635 Given
2636   class A {
2637    public:
2638     virtual void x();
2639   };
2640   class B : public A {
2641    public:
2642     virtual void x();
2643   };
2644   matches B::x
2645 </pre></td></tr>
2646
2647
2648 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isPure0')"><a name="isPure0Anchor">isPure</a></td><td></td></tr>
2649 <tr><td colspan="4" class="doc" id="isPure0"><pre>Matches if the given method declaration is pure.
2650
2651 Given
2652   class A {
2653    public:
2654     virtual void x() = 0;
2655   };
2656   matches A::x
2657 </pre></td></tr>
2658
2659
2660 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isUserProvided0')"><a name="isUserProvided0Anchor">isUserProvided</a></td><td></td></tr>
2661 <tr><td colspan="4" class="doc" id="isUserProvided0"><pre>Matches method declarations that are user-provided.
2662
2663 Given
2664   struct S {
2665     S(); // #1
2666     S(const S &amp;) = default; // #2
2667     S(S &amp;&amp;) = delete; // #3
2668   };
2669 cxxConstructorDecl(isUserProvided()) will match #1, but not #2 or #3.
2670 </pre></td></tr>
2671
2672
2673 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isVirtual0')"><a name="isVirtual0Anchor">isVirtual</a></td><td></td></tr>
2674 <tr><td colspan="4" class="doc" id="isVirtual0"><pre>Matches declarations of virtual methods and C++ base specifers that specify
2675 virtual inheritance.
2676
2677 Example:
2678   class A {
2679    public:
2680     virtual void x(); // matches x
2681   };
2682
2683 Example:
2684   class Base {};
2685   class DirectlyDerived : virtual Base {}; // matches Base
2686   class IndirectlyDerived : DirectlyDerived, Base {}; // matches Base
2687
2688 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBaseSpecifier.html">CXXBaseSpecifier</a>&gt;
2689 </pre></td></tr>
2690
2691
2692 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('isVirtualAsWritten0')"><a name="isVirtualAsWritten0Anchor">isVirtualAsWritten</a></td><td></td></tr>
2693 <tr><td colspan="4" class="doc" id="isVirtualAsWritten0"><pre>Matches if the given method declaration has an explicit "virtual".
2694
2695 Given
2696   class A {
2697    public:
2698     virtual void x();
2699   };
2700   class B : public A {
2701    public:
2702     void x();
2703   };
2704   matches A::x but not B::x
2705 </pre></td></tr>
2706
2707
2708 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXNewExpr.html">CXXNewExpr</a>&gt;</td><td class="name" onclick="toggle('isArray0')"><a name="isArray0Anchor">isArray</a></td><td></td></tr>
2709 <tr><td colspan="4" class="doc" id="isArray0"><pre>Matches array new expressions.
2710
2711 Given:
2712   MyClass *p1 = new MyClass[10];
2713 cxxNewExpr(isArray())
2714   matches the expression 'new MyClass[10]'.
2715 </pre></td></tr>
2716
2717
2718 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasAnyOverloadedOperatorName0')"><a name="hasAnyOverloadedOperatorName0Anchor">hasAnyOverloadedOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
2719 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName0"><pre>Matches overloaded operator names.
2720
2721 Matches overloaded operator names specified in strings without the
2722 "operator" prefix: e.g. "&lt;&lt;".
2723
2724   hasAnyOverloadesOperatorName("+", "-")
2725 Is equivalent to
2726   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
2727 </pre></td></tr>
2728
2729
2730 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('hasOverloadedOperatorName1')"><a name="hasOverloadedOperatorName1Anchor">hasOverloadedOperatorName</a></td><td>StringRef Name</td></tr>
2731 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName1"><pre>Matches overloaded operator names.
2732
2733 Matches overloaded operator names specified in strings without the
2734 "operator" prefix: e.g. "&lt;&lt;".
2735
2736 Given:
2737   class A { int operator*(); };
2738   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
2739   A a;
2740   a &lt;&lt; a;   // &lt;-- This matches
2741
2742 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
2743 specified line and
2744 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
2745 matches the declaration of A.
2746
2747 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
2748 </pre></td></tr>
2749
2750
2751 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('isAssignmentOperator1')"><a name="isAssignmentOperator1Anchor">isAssignmentOperator</a></td><td></td></tr>
2752 <tr><td colspan="4" class="doc" id="isAssignmentOperator1"><pre>Matches all kinds of assignment operators.
2753
2754 Example 1: matches a += b (matcher = binaryOperator(isAssignmentOperator()))
2755   if (a == b)
2756     a += b;
2757
2758 Example 2: matches s1 = s2
2759            (matcher = cxxOperatorCallExpr(isAssignmentOperator()))
2760   struct S { S&amp; operator=(const S&amp;); };
2761   void x() { S s1, s2; s1 = s2; }
2762 </pre></td></tr>
2763
2764
2765 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;</td><td class="name" onclick="toggle('isComparisonOperator1')"><a name="isComparisonOperator1Anchor">isComparisonOperator</a></td><td></td></tr>
2766 <tr><td colspan="4" class="doc" id="isComparisonOperator1"><pre>Matches comparison operators.
2767
2768 Example 1: matches a == b (matcher = binaryOperator(isComparisonOperator()))
2769   if (a == b)
2770     a += b;
2771
2772 Example 2: matches s1 &lt; s2
2773            (matcher = cxxOperatorCallExpr(isComparisonOperator()))
2774   struct S { bool operator&lt;(const S&amp; other); };
2775   void x(S s1, S s2) { bool b1 = s1 &lt; s2; }
2776 </pre></td></tr>
2777
2778
2779 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('hasDefinition0')"><a name="hasDefinition0Anchor">hasDefinition</a></td><td></td></tr>
2780 <tr><td colspan="4" class="doc" id="hasDefinition0"><pre>Matches a class declaration that is defined.
2781
2782 Example matches x (matcher = cxxRecordDecl(hasDefinition()))
2783 class x {};
2784 class y;
2785 </pre></td></tr>
2786
2787
2788 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDerivedFrom2')"><a name="isDerivedFrom2Anchor">isDerivedFrom</a></td><td>std::string BaseName</td></tr>
2789 <tr><td colspan="4" class="doc" id="isDerivedFrom2"><pre>Overloaded method as shortcut for isDerivedFrom(hasName(...)).
2790 </pre></td></tr>
2791
2792
2793 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isDirectlyDerivedFrom2')"><a name="isDirectlyDerivedFrom2Anchor">isDirectlyDerivedFrom</a></td><td>std::string BaseName</td></tr>
2794 <tr><td colspan="4" class="doc" id="isDirectlyDerivedFrom2"><pre>Overloaded method as shortcut for isDirectlyDerivedFrom(hasName(...)).
2795 </pre></td></tr>
2796
2797
2798 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isExplicitTemplateSpecialization2')"><a name="isExplicitTemplateSpecialization2Anchor">isExplicitTemplateSpecialization</a></td><td></td></tr>
2799 <tr><td colspan="4" class="doc" id="isExplicitTemplateSpecialization2"><pre>Matches explicit template specializations of function, class, or
2800 static member variable template instantiations.
2801
2802 Given
2803   template&lt;typename T&gt; void A(T t) { }
2804   template&lt;&gt; void A(int N) { }
2805 functionDecl(isExplicitTemplateSpecialization())
2806   matches the specialization A&lt;int&gt;().
2807
2808 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
2809 </pre></td></tr>
2810
2811
2812 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isFinal0')"><a name="isFinal0Anchor">isFinal</a></td><td></td></tr>
2813 <tr><td colspan="4" class="doc" id="isFinal0"><pre>Matches if the given method or class declaration is final.
2814
2815 Given:
2816   class A final {};
2817
2818   struct B {
2819     virtual void f();
2820   };
2821
2822   struct C : B {
2823     void f() final;
2824   };
2825 matches A and C::f, but not B, C, or B::f
2826 </pre></td></tr>
2827
2828
2829 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isLambda0')"><a name="isLambda0Anchor">isLambda</a></td><td></td></tr>
2830 <tr><td colspan="4" class="doc" id="isLambda0"><pre>Matches the generated class of lambda expressions.
2831
2832 Given:
2833   auto x = []{};
2834
2835 cxxRecordDecl(isLambda()) matches the implicit class declaration of
2836 decltype(x)
2837 </pre></td></tr>
2838
2839
2840 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isSameOrDerivedFrom2')"><a name="isSameOrDerivedFrom2Anchor">isSameOrDerivedFrom</a></td><td>std::string BaseName</td></tr>
2841 <tr><td colspan="4" class="doc" id="isSameOrDerivedFrom2"><pre>Overloaded method as shortcut for
2842 isSameOrDerivedFrom(hasName(...)).
2843 </pre></td></tr>
2844
2845
2846 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;</td><td class="name" onclick="toggle('isTemplateInstantiation2')"><a name="isTemplateInstantiation2Anchor">isTemplateInstantiation</a></td><td></td></tr>
2847 <tr><td colspan="4" class="doc" id="isTemplateInstantiation2"><pre>Matches template instantiations of function, class, or static
2848 member variable template instantiations.
2849
2850 Given
2851   template &lt;typename T&gt; class X {}; class A {}; X&lt;A&gt; x;
2852 or
2853   template &lt;typename T&gt; class X {}; class A {}; template class X&lt;A&gt;;
2854 or
2855   template &lt;typename T&gt; class X {}; class A {}; extern template class X&lt;A&gt;;
2856 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2857   matches the template instantiation of X&lt;A&gt;.
2858
2859 But given
2860   template &lt;typename T&gt;  class X {}; class A {};
2861   template &lt;&gt; class X&lt;A&gt; {}; X&lt;A&gt; x;
2862 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
2863   does not match, as X&lt;A&gt; is an explicit template specialization.
2864
2865 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1VarDecl.html">VarDecl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html">CXXRecordDecl</a>&gt;
2866 </pre></td></tr>
2867
2868
2869 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('argumentCountIs0')"><a name="argumentCountIs0Anchor">argumentCountIs</a></td><td>unsigned N</td></tr>
2870 <tr><td colspan="4" class="doc" id="argumentCountIs0"><pre>Checks that a call expression or a constructor call expression has
2871 a specific number of arguments (including absent default arguments).
2872
2873 Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
2874   void f(int x, int y);
2875   f(0, 0);
2876 </pre></td></tr>
2877
2878
2879 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CallExpr.html">CallExpr</a>&gt;</td><td class="name" onclick="toggle('usesADL0')"><a name="usesADL0Anchor">usesADL</a></td><td></td></tr>
2880 <tr><td colspan="4" class="doc" id="usesADL0"><pre>Matches call expressions which were resolved using ADL.
2881
2882 Example matches y(x) but not y(42) or NS::y(x).
2883   namespace NS {
2884     struct X {};
2885     void y(X);
2886   }
2887
2888   void y(...);
2889
2890   void test() {
2891     NS::X x;
2892     y(x); // Matches
2893     NS::y(x); // Doesn't match
2894     y(42); // Doesn't match
2895     using NS::y;
2896     y(x); // Found by both unqualified lookup and ADL, doesn't match
2897    }
2898 </pre></td></tr>
2899
2900
2901 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CastExpr.html">CastExpr</a>&gt;</td><td class="name" onclick="toggle('hasCastKind0')"><a name="hasCastKind0Anchor">hasCastKind</a></td><td>CastKind Kind</td></tr>
2902 <tr><td colspan="4" class="doc" id="hasCastKind0"><pre>Matches casts that has a given cast kind.
2903
2904 Example: matches the implicit cast around 0
2905 (matcher = castExpr(hasCastKind(CK_NullToPointer)))
2906   int *p = 0;
2907
2908 If the matcher is use from clang-query, CastKind parameter
2909 should be passed as a quoted string. e.g., hasCastKind("CK_NullToPointer").
2910 </pre></td></tr>
2911
2912
2913 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals4')"><a name="equals4Anchor">equals</a></td><td>bool Value</td></tr>
2914 <tr><td colspan="4" class="doc" id="equals4"><pre></pre></td></tr>
2915
2916
2917 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals3')"><a name="equals3Anchor">equals</a></td><td>const ValueT  Value</td></tr>
2918 <tr><td colspan="4" class="doc" id="equals3"><pre>Matches literals that are equal to the given value of type ValueT.
2919
2920 Given
2921   f('false, 3.14, 42);
2922 characterLiteral(equals(0))
2923   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
2924   match false
2925 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
2926   match 3.14
2927 integerLiteral(equals(42))
2928   matches 42
2929
2930 Note that you cannot directly match a negative numeric literal because the
2931 minus sign is not part of the literal: It is a unary operator whose operand
2932 is the positive numeric literal. Instead, you must use a unaryOperator()
2933 matcher to match the minus sign:
2934
2935 unaryOperator(hasOperatorName("-"),
2936               hasUnaryOperand(integerLiteral(equals(13))))
2937
2938 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
2939            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
2940 </pre></td></tr>
2941
2942
2943 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals10')"><a name="equals10Anchor">equals</a></td><td>double Value</td></tr>
2944 <tr><td colspan="4" class="doc" id="equals10"><pre></pre></td></tr>
2945
2946
2947 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;</td><td class="name" onclick="toggle('equals7')"><a name="equals7Anchor">equals</a></td><td>unsigned Value</td></tr>
2948 <tr><td colspan="4" class="doc" id="equals7"><pre></pre></td></tr>
2949
2950
2951 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ClassTemplateSpecializationDecl.html">ClassTemplateSpecializationDecl</a>&gt;</td><td class="name" onclick="toggle('templateArgumentCountIs0')"><a name="templateArgumentCountIs0Anchor">templateArgumentCountIs</a></td><td>unsigned N</td></tr>
2952 <tr><td colspan="4" class="doc" id="templateArgumentCountIs0"><pre>Matches if the number of template arguments equals N.
2953
2954 Given
2955   template&lt;typename T&gt; struct C {};
2956   C&lt;int&gt; c;
2957 classTemplateSpecializationDecl(templateArgumentCountIs(1))
2958   matches C&lt;int&gt;.
2959 </pre></td></tr>
2960
2961
2962 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CompoundStmt.html">CompoundStmt</a>&gt;</td><td class="name" onclick="toggle('statementCountIs0')"><a name="statementCountIs0Anchor">statementCountIs</a></td><td>unsigned N</td></tr>
2963 <tr><td colspan="4" class="doc" id="statementCountIs0"><pre>Checks that a compound statement contains a specific number of
2964 child statements.
2965
2966 Example: Given
2967   { for (;;) {} }
2968 compoundStmt(statementCountIs(0)))
2969   matches '{}'
2970   but does not match the outer compound statement.
2971 </pre></td></tr>
2972
2973
2974 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ConstantArrayType.html">ConstantArrayType</a>&gt;</td><td class="name" onclick="toggle('hasSize0')"><a name="hasSize0Anchor">hasSize</a></td><td>unsigned N</td></tr>
2975 <tr><td colspan="4" class="doc" id="hasSize0"><pre>Matches nodes that have the specified size.
2976
2977 Given
2978   int a[42];
2979   int b[2 * 21];
2980   int c[41], d[43];
2981   char *s = "abcd";
2982   wchar_t *ws = L"abcd";
2983   char *w = "a";
2984 constantArrayType(hasSize(42))
2985   matches "int a[42]" and "int b[2 * 21]"
2986 stringLiteral(hasSize(4))
2987   matches "abcd", L"abcd"
2988 </pre></td></tr>
2989
2990
2991 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DeclStmt.html">DeclStmt</a>&gt;</td><td class="name" onclick="toggle('declCountIs0')"><a name="declCountIs0Anchor">declCountIs</a></td><td>unsigned N</td></tr>
2992 <tr><td colspan="4" class="doc" id="declCountIs0"><pre>Matches declaration statements that contain a specific number of
2993 declarations.
2994
2995 Example: Given
2996   int a, b;
2997   int c;
2998   int d = 2, e;
2999 declCountIs(2)
3000   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
3001 </pre></td></tr>
3002
3003
3004 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsBoundNode1')"><a name="equalsBoundNode1Anchor">equalsBoundNode</a></td><td>std::string ID</td></tr>
3005 <tr><td colspan="4" class="doc" id="equalsBoundNode1"><pre>Matches if a node equals a previously bound node.
3006
3007 Matches a node if it equals the node previously bound to ID.
3008
3009 Given
3010   class X { int a; int b; };
3011 cxxRecordDecl(
3012     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
3013     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
3014   matches the class X, as a and b have the same type.
3015
3016 Note that when multiple matches are involved via forEach* matchers,
3017 equalsBoundNodes acts as a filter.
3018 For example:
3019 compoundStmt(
3020     forEachDescendant(varDecl().bind("d")),
3021     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
3022 will trigger a match for each combination of variable declaration
3023 and reference to that variable declaration within a compound statement.
3024 </pre></td></tr>
3025
3026
3027 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('equalsNode0')"><a name="equalsNode0Anchor">equalsNode</a></td><td>const Decl* Other</td></tr>
3028 <tr><td colspan="4" class="doc" id="equalsNode0"><pre>Matches if a node equals another node.
3029
3030 Decl has pointer identity in the AST.
3031 </pre></td></tr>
3032
3033
3034 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('hasAttr0')"><a name="hasAttr0Anchor">hasAttr</a></td><td>attr::Kind AttrKind</td></tr>
3035 <tr><td colspan="4" class="doc" id="hasAttr0"><pre>Matches declaration that has a given attribute.
3036
3037 Given
3038   __attribute__((device)) void f() { ... }
3039 decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
3040 f. If the matcher is used from clang-query, attr::Kind parameter should be
3041 passed as a quoted string. e.g., hasAttr("attr::CUDADevice").
3042 </pre></td></tr>
3043
3044
3045 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInFileMatching0')"><a name="isExpansionInFileMatching0Anchor">isExpansionInFileMatching</a></td><td>StringRef RegExp, Regex::RegexFlags Flags = NoFlags</td></tr>
3046 <tr><td colspan="4" class="doc" id="isExpansionInFileMatching0"><pre>Matches AST nodes that were expanded within files whose name is
3047 partially matching a given regex.
3048
3049 Example matches Y but not X
3050     (matcher = cxxRecordDecl(isExpansionInFileMatching("AST.*"))
3051   #include "ASTMatcher.h"
3052   class X {};
3053 ASTMatcher.h:
3054   class Y {};
3055
3056 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3057
3058 If the matcher is used in clang-query, RegexFlags parameter
3059 should be passed as a quoted string. e.g: "NoFlags".
3060 Flags can be combined with '|' example "IgnoreCase | BasicRegex"
3061 </pre></td></tr>
3062
3063
3064 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInMainFile0')"><a name="isExpansionInMainFile0Anchor">isExpansionInMainFile</a></td><td></td></tr>
3065 <tr><td colspan="4" class="doc" id="isExpansionInMainFile0"><pre>Matches AST nodes that were expanded within the main-file.
3066
3067 Example matches X but not Y
3068   (matcher = cxxRecordDecl(isExpansionInMainFile())
3069   #include &lt;Y.h&gt;
3070   class X {};
3071 Y.h:
3072   class Y {};
3073
3074 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3075 </pre></td></tr>
3076
3077
3078 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isExpansionInSystemHeader0')"><a name="isExpansionInSystemHeader0Anchor">isExpansionInSystemHeader</a></td><td></td></tr>
3079 <tr><td colspan="4" class="doc" id="isExpansionInSystemHeader0"><pre>Matches AST nodes that were expanded within system-header-files.
3080
3081 Example matches Y but not X
3082     (matcher = cxxRecordDecl(isExpansionInSystemHeader())
3083   #include &lt;SystemHeader.h&gt;
3084   class X {};
3085 SystemHeader.h:
3086   class Y {};
3087
3088 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypeLoc.html">TypeLoc</a>&gt;
3089 </pre></td></tr>
3090
3091
3092 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isImplicit0')"><a name="isImplicit0Anchor">isImplicit</a></td><td></td></tr>
3093 <tr><td colspan="4" class="doc" id="isImplicit0"><pre>Matches a declaration that has been implicitly added
3094 by the compiler (eg. implicit default/copy constructors).
3095 </pre></td></tr>
3096
3097
3098 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isInStdNamespace0')"><a name="isInStdNamespace0Anchor">isInStdNamespace</a></td><td></td></tr>
3099 <tr><td colspan="4" class="doc" id="isInStdNamespace0"><pre>Matches declarations in the namespace `std`, but not in nested namespaces.
3100
3101 Given
3102   class vector {};
3103   namespace foo {
3104     class vector {};
3105     namespace std {
3106       class vector {};
3107     }
3108   }
3109   namespace std {
3110     inline namespace __1 {
3111       class vector {}; // #1
3112       namespace experimental {
3113         class vector {};
3114       }
3115     }
3116   }
3117 cxxRecordDecl(hasName("vector"), isInStdNamespace()) will match only #1.
3118 </pre></td></tr>
3119
3120
3121 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isInstantiated0')"><a name="isInstantiated0Anchor">isInstantiated</a></td><td></td></tr>
3122 <tr><td colspan="4" class="doc" id="isInstantiated0"><pre>Matches declarations that are template instantiations or are inside
3123 template instantiations.
3124
3125 Given
3126   template&lt;typename T&gt; void A(T t) { T i; }
3127   A(0);
3128   A(0U);
3129 functionDecl(isInstantiated())
3130   matches 'A(int) {...};' and 'A(unsigned) {...}'.
3131 </pre></td></tr>
3132
3133
3134 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isPrivate0')"><a name="isPrivate0Anchor">isPrivate</a></td><td></td></tr>
3135 <tr><td colspan="4" class="doc" id="isPrivate0"><pre>Matches private C++ declarations and C++ base specifers that specify private
3136 inheritance.
3137
3138 Examples:
3139   class C {
3140   public:    int a;
3141   protected: int b;
3142   private:   int c; // fieldDecl(isPrivate()) matches 'c'
3143   };
3144
3145   struct Base {};
3146   struct Derived1 : private Base {}; // matches 'Base'
3147   class Derived2 : Base {}; // matches 'Base'
3148 </pre></td></tr>
3149
3150
3151 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isProtected0')"><a name="isProtected0Anchor">isProtected</a></td><td></td></tr>
3152 <tr><td colspan="4" class="doc" id="isProtected0"><pre>Matches protected C++ declarations and C++ base specifers that specify
3153 protected inheritance.
3154
3155 Examples:
3156   class C {
3157   public:    int a;
3158   protected: int b; // fieldDecl(isProtected()) matches 'b'
3159   private:   int c;
3160   };
3161
3162   class Base {};
3163   class Derived : protected Base {}; // matches 'Base'
3164 </pre></td></tr>
3165
3166
3167 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;</td><td class="name" onclick="toggle('isPublic0')"><a name="isPublic0Anchor">isPublic</a></td><td></td></tr>
3168 <tr><td colspan="4" class="doc" id="isPublic0"><pre>Matches public C++ declarations and C++ base specifers that specify public
3169 inheritance.
3170
3171 Examples:
3172   class C {
3173   public:    int a; // fieldDecl(isPublic()) matches 'a'
3174   protected: int b;
3175   private:   int c;
3176   };
3177
3178   class Base {};
3179   class Derived1 : public Base {}; // matches 'Base'
3180   struct Derived2 : Base {}; // matches 'Base'
3181 </pre></td></tr>
3182
3183
3184 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1DesignatedInitExpr.html">DesignatedInitExpr</a>&gt;</td><td class="name" onclick="toggle('designatorCountIs0')"><a name="designatorCountIs0Anchor">designatorCountIs</a></td><td>unsigned N</td></tr>
3185 <tr><td colspan="4" class="doc" id="designatorCountIs0"><pre>Matches designated initializer expressions that contain
3186 a specific number of designators.
3187
3188 Example: Given
3189   point ptarray[10] = { [2].y = 1.0, [0].x = 1.0 };
3190   point ptarray2[10] = { [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 };
3191 designatorCountIs(2)
3192   matches '{ [2].y = 1.0, [0].x = 1.0 }',
3193   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
3194 </pre></td></tr>
3195
3196
3197 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1EnumDecl.html">EnumDecl</a>&gt;</td><td class="name" onclick="toggle('isScoped0')"><a name="isScoped0Anchor">isScoped</a></td><td></td></tr>
3198 <tr><td colspan="4" class="doc" id="isScoped0"><pre>Matches C++11 scoped enum declaration.
3199
3200 Example matches Y (matcher = enumDecl(isScoped()))
3201 enum X {};
3202 enum class Y {};
3203 </pre></td></tr>
3204
3205
3206 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isInstantiationDependent0')"><a name="isInstantiationDependent0Anchor">isInstantiationDependent</a></td><td></td></tr>
3207 <tr><td colspan="4" class="doc" id="isInstantiationDependent0"><pre>Matches expressions that are instantiation-dependent even if it is
3208 neither type- nor value-dependent.
3209
3210 In the following example, the expression sizeof(sizeof(T() + T()))
3211 is instantiation-dependent (since it involves a template parameter T),
3212 but is neither type- nor value-dependent, since the type of the inner
3213 sizeof is known (std::size_t) and therefore the size of the outer
3214 sizeof is known.
3215   template&lt;typename T&gt;
3216   void f(T x, T y) { sizeof(sizeof(T() + T()); }
3217 expr(isInstantiationDependent()) matches sizeof(sizeof(T() + T())
3218 </pre></td></tr>
3219
3220
3221 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isTypeDependent0')"><a name="isTypeDependent0Anchor">isTypeDependent</a></td><td></td></tr>
3222 <tr><td colspan="4" class="doc" id="isTypeDependent0"><pre>Matches expressions that are type-dependent because the template type
3223 is not yet instantiated.
3224
3225 For example, the expressions "x" and "x + y" are type-dependent in
3226 the following code, but "y" is not type-dependent:
3227   template&lt;typename T&gt;
3228   void add(T x, int y) {
3229     x + y;
3230   }
3231 expr(isTypeDependent()) matches x + y
3232 </pre></td></tr>
3233
3234
3235 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('isValueDependent0')"><a name="isValueDependent0Anchor">isValueDependent</a></td><td></td></tr>
3236 <tr><td colspan="4" class="doc" id="isValueDependent0"><pre>Matches expression that are value-dependent because they contain a
3237 non-type template parameter.
3238
3239 For example, the array bound of "Chars" in the following example is
3240 value-dependent.
3241   template&lt;int Size&gt; int f() { return Size; }
3242 expr(isValueDependent()) matches return Size
3243 </pre></td></tr>
3244
3245
3246 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt;</td><td class="name" onclick="toggle('nullPointerConstant0')"><a name="nullPointerConstant0Anchor">nullPointerConstant</a></td><td></td></tr>
3247 <tr><td colspan="4" class="doc" id="nullPointerConstant0"><pre>Matches expressions that resolve to a null pointer constant, such as
3248 GNU's __null, C++11's nullptr, or C's NULL macro.
3249
3250 Given:
3251   void *v1 = NULL;
3252   void *v2 = nullptr;
3253   void *v3 = __null; // GNU extension
3254   char *cp = (char *)0;
3255   int *ip = 0;
3256   int i = 0;
3257 expr(nullPointerConstant())
3258   matches the initializer for v1, v2, v3, cp, and ip. Does not match the
3259   initializer for i.
3260 </pre></td></tr>
3261
3262
3263 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('hasBitWidth0')"><a name="hasBitWidth0Anchor">hasBitWidth</a></td><td>unsigned Width</td></tr>
3264 <tr><td colspan="4" class="doc" id="hasBitWidth0"><pre>Matches non-static data members that are bit-fields of the specified
3265 bit width.
3266
3267 Given
3268   class C {
3269     int a : 2;
3270     int b : 4;
3271     int c : 2;
3272   };
3273 fieldDecl(hasBitWidth(2))
3274   matches 'int a;' and 'int c;' but not 'int b;'.
3275 </pre></td></tr>
3276
3277
3278 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FieldDecl.html">FieldDecl</a>&gt;</td><td class="name" onclick="toggle('isBitField0')"><a name="isBitField0Anchor">isBitField</a></td><td></td></tr>
3279 <tr><td colspan="4" class="doc" id="isBitField0"><pre>Matches non-static data members that are bit-fields.
3280
3281 Given
3282   class C {
3283     int a : 2;
3284     int b;
3285   };
3286 fieldDecl(isBitField())
3287   matches 'int a;' but not 'int b;'.
3288 </pre></td></tr>
3289
3290
3291 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;</td><td class="name" onclick="toggle('equals1')"><a name="equals1Anchor">equals</a></td><td>const ValueT  Value</td></tr>
3292 <tr><td colspan="4" class="doc" id="equals1"><pre>Matches literals that are equal to the given value of type ValueT.
3293
3294 Given
3295   f('false, 3.14, 42);
3296 characterLiteral(equals(0))
3297   matches 'cxxBoolLiteral(equals(false)) and cxxBoolLiteral(equals(0))
3298   match false
3299 floatLiteral(equals(3.14)) and floatLiteral(equals(314e-2))
3300   match 3.14
3301 integerLiteral(equals(42))
3302   matches 42
3303
3304 Note that you cannot directly match a negative numeric literal because the
3305 minus sign is not part of the literal: It is a unary operator whose operand
3306 is the positive numeric literal. Instead, you must use a unaryOperator()
3307 matcher to match the minus sign:
3308
3309 unaryOperator(hasOperatorName("-"),
3310               hasUnaryOperand(integerLiteral(equals(13))))
3311
3312 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CharacterLiteral.html">CharacterLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXBoolLiteralExpr.html">CXXBoolLiteralExpr</a>&gt;,
3313            Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1IntegerLiteral.html">IntegerLiteral</a>&gt;
3314 </pre></td></tr>
3315
3316
3317 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FloatingLiteral.html">FloatingLiteral</a>&gt;</td><td class="name" onclick="toggle('equals12')"><a name="equals12Anchor">equals</a></td><td>double Value</td></tr>
3318 <tr><td colspan="4" class="doc" id="equals12"><pre></pre></td></tr>
3319
3320
3321 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasAnyOverloadedOperatorName1')"><a name="hasAnyOverloadedOperatorName1Anchor">hasAnyOverloadedOperatorName</a></td><td>StringRef, ..., StringRef</td></tr>
3322 <tr><td colspan="4" class="doc" id="hasAnyOverloadedOperatorName1"><pre>Matches overloaded operator names.
3323
3324 Matches overloaded operator names specified in strings without the
3325 "operator" prefix: e.g. "&lt;&lt;".
3326
3327   hasAnyOverloadesOperatorName("+", "-")
3328 Is equivalent to
3329   anyOf(hasOverloadedOperatorName("+"), hasOverloadedOperatorName("-"))
3330 </pre></td></tr>
3331
3332
3333 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasDynamicExceptionSpec0')"><a name="hasDynamicExceptionSpec0Anchor">hasDynamicExceptionSpec</a></td><td></td></tr>
3334 <tr><td colspan="4" class="doc" id="hasDynamicExceptionSpec0"><pre>Matches functions that have a dynamic exception specification.
3335
3336 Given:
3337   void f();
3338   void g() noexcept;
3339   void h() noexcept(true);
3340   void i() noexcept(false);
3341   void j() throw();
3342   void k() throw(int);
3343   void l() throw(...);
3344 functionDecl(hasDynamicExceptionSpec()) and
3345   functionProtoType(hasDynamicExceptionSpec())
3346   match the declarations of j, k, and l, but not f, g, h, or i.
3347 </pre></td></tr>
3348
3349
3350 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasOverloadedOperatorName0')"><a name="hasOverloadedOperatorName0Anchor">hasOverloadedOperatorName</a></td><td>StringRef Name</td></tr>
3351 <tr><td colspan="4" class="doc" id="hasOverloadedOperatorName0"><pre>Matches overloaded operator names.
3352
3353 Matches overloaded operator names specified in strings without the
3354 "operator" prefix: e.g. "&lt;&lt;".
3355
3356 Given:
3357   class A { int operator*(); };
3358   const A &amp;operator&lt;&lt;(const A &amp;a, const A &amp;b);
3359   A a;
3360   a &lt;&lt; a;   // &lt;-- This matches
3361
3362 cxxOperatorCallExpr(hasOverloadedOperatorName("&lt;&lt;"))) matches the
3363 specified line and
3364 cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")))
3365 matches the declaration of A.
3366
3367 Usable as: Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1CXXOperatorCallExpr.html">CXXOperatorCallExpr</a>&gt;, Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;
3368 </pre></td></tr>
3369
3370
3371 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('hasTrailingReturn0')"><a name="hasTrailingReturn0Anchor">hasTrailingReturn</a></td><td></td></tr>
3372 <tr><td colspan="4" class="doc" id="hasTrailingReturn0"><pre>Matches a function declared with a trailing return type.
3373
3374 Example matches Y (matcher = functionDecl(hasTrailingReturn()))
3375 int X() {}
3376 auto Y() -&gt; int {}
3377 </pre></td></tr>
3378
3379
3380 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isConstexpr1')"><a name="isConstexpr1Anchor">isConstexpr</a></td><td></td></tr>
3381 <tr><td colspan="4" class="doc" id="isConstexpr1"><pre>Matches constexpr variable and function declarations,
3382        and if constexpr.
3383
3384 Given:
3385   constexpr int foo = 42;
3386   constexpr int bar();
3387   void baz() { if constexpr(1 &gt; 0) {} }
3388 varDecl(isConstexpr())
3389   matches the declaration of foo.
3390 functionDecl(isConstexpr())
3391   matches the declaration of bar.
3392 ifStmt(isConstexpr())
3393   matches the if statement in baz.
3394 </pre></td></tr>
3395
3396
3397 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt;</td><td class="name" onclick="toggle('isDefaulted0')"><a name="isDefaulted0Anchor">isDefaulted</a></td><td></td></tr>
3398 <tr><td colspan="4" class="doc" id="isDefaulted0"><pre>Matches defaulted function declarations.
3399
3400 Given:
3401   class A { ~A(); };
3402   class B { ~B() = default; };
3403 functionDecl(isDefaulted())
3404   matches the declaration of ~B, but not ~A.
3405 </pre></td></tr>
3406
3407