1//= unittests/ASTMatchers/ASTMatchersTraversalTest.cpp - matchers unit tests =//
2//
3//                     The LLVM Compiler Infrastructure
4//`
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "ASTMatchersTest.h"
11#include "clang/AST/PrettyPrinter.h"
12#include "clang/ASTMatchers/ASTMatchFinder.h"
13#include "clang/ASTMatchers/ASTMatchers.h"
14#include "clang/Tooling/Tooling.h"
15#include "llvm/ADT/Triple.h"
16#include "llvm/Support/Host.h"
17#include "gtest/gtest.h"
18
19namespace clang {
20namespace ast_matchers {
21
22TEST(DeclarationMatcher, hasMethod) {
23  EXPECT_TRUE(matches("class A { void func(); };",
24                      cxxRecordDecl(hasMethod(hasName("func")))));
25  EXPECT_TRUE(notMatches("class A { void func(); };",
26                         cxxRecordDecl(hasMethod(isPublic()))));
27}
28
29TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
30  EXPECT_TRUE(matches(
31    "template <typename T> struct A {"
32      "  template <typename T2> struct F {};"
33      "};"
34      "template <typename T> struct B : A<T>::template F<T> {};"
35      "B<int> b;",
36    cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
37}
38
39TEST(DeclarationMatcher, hasDeclContext) {
40  EXPECT_TRUE(matches(
41    "namespace N {"
42      "  namespace M {"
43      "    class D {};"
44      "  }"
45      "}",
46    recordDecl(hasDeclContext(namespaceDecl(hasName("M"))))));
47  EXPECT_TRUE(notMatches(
48    "namespace N {"
49      "  namespace M {"
50      "    class D {};"
51      "  }"
52      "}",
53    recordDecl(hasDeclContext(namespaceDecl(hasName("N"))))));
54
55  EXPECT_TRUE(matches("namespace {"
56                        "  namespace M {"
57                        "    class D {};"
58                        "  }"
59                        "}",
60                      recordDecl(hasDeclContext(namespaceDecl(
61                        hasName("M"), hasDeclContext(namespaceDecl()))))));
62
63  EXPECT_TRUE(matches("class D{};", decl(hasDeclContext(decl()))));
64}
65
66TEST(HasDescendant, MatchesDescendantTypes) {
67  EXPECT_TRUE(matches("void f() { int i = 3; }",
68                      decl(hasDescendant(loc(builtinType())))));
69  EXPECT_TRUE(matches("void f() { int i = 3; }",
70                      stmt(hasDescendant(builtinType()))));
71
72  EXPECT_TRUE(matches("void f() { int i = 3; }",
73                      stmt(hasDescendant(loc(builtinType())))));
74  EXPECT_TRUE(matches("void f() { int i = 3; }",
75                      stmt(hasDescendant(qualType(builtinType())))));
76
77  EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
78                         stmt(hasDescendant(isInteger()))));
79
80  EXPECT_TRUE(matchAndVerifyResultTrue(
81    "void f() { int a; float c; int d; int e; }",
82    functionDecl(forEachDescendant(
83      varDecl(hasDescendant(isInteger())).bind("x"))),
84    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 3)));
85}
86
87TEST(HasDescendant, MatchesDescendantsOfTypes) {
88  EXPECT_TRUE(matches("void f() { int*** i; }",
89                      qualType(hasDescendant(builtinType()))));
90  EXPECT_TRUE(matches("void f() { int*** i; }",
91                      qualType(hasDescendant(
92                        pointerType(pointee(builtinType()))))));
93  EXPECT_TRUE(matches("void f() { int*** i; }",
94                      typeLoc(hasDescendant(loc(builtinType())))));
95
96  EXPECT_TRUE(matchAndVerifyResultTrue(
97    "void f() { int*** i; }",
98    qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
99    llvm::make_unique<VerifyIdIsBoundTo<Type>>("x", 2)));
100}
101
102
103TEST(Has, MatchesChildrenOfTypes) {
104  EXPECT_TRUE(matches("int i;",
105                      varDecl(hasName("i"), has(isInteger()))));
106  EXPECT_TRUE(notMatches("int** i;",
107                         varDecl(hasName("i"), has(isInteger()))));
108  EXPECT_TRUE(matchAndVerifyResultTrue(
109    "int (*f)(float, int);",
110    qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
111    llvm::make_unique<VerifyIdIsBoundTo<QualType>>("x", 2)));
112}
113
114TEST(Has, MatchesChildTypes) {
115  EXPECT_TRUE(matches(
116    "int* i;",
117    varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
118  EXPECT_TRUE(notMatches(
119    "int* i;",
120    varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
121}
122
123TEST(StatementMatcher, Has) {
124  StatementMatcher HasVariableI =
125      expr(hasType(pointsTo(recordDecl(hasName("X")))),
126           has(ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("i")))))));
127
128  EXPECT_TRUE(matches(
129    "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
130  EXPECT_TRUE(notMatches(
131    "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
132}
133
134TEST(StatementMatcher, HasDescendant) {
135  StatementMatcher HasDescendantVariableI =
136    expr(hasType(pointsTo(recordDecl(hasName("X")))),
137         hasDescendant(declRefExpr(to(varDecl(hasName("i"))))));
138
139  EXPECT_TRUE(matches(
140    "class X; X *x(bool); bool b(int); void c() { int i; x(b(i)); }",
141    HasDescendantVariableI));
142  EXPECT_TRUE(notMatches(
143    "class X; X *x(bool); bool b(int); void c() { int i; x(b(42)); }",
144    HasDescendantVariableI));
145}
146
147TEST(TypeMatcher, MatchesClassType) {
148  TypeMatcher TypeA = hasDeclaration(recordDecl(hasName("A")));
149
150  EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
151  EXPECT_TRUE(notMatches("class A {};", TypeA));
152
153  TypeMatcher TypeDerivedFromA =
154    hasDeclaration(cxxRecordDecl(isDerivedFrom("A")));
155
156  EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
157                      TypeDerivedFromA));
158  EXPECT_TRUE(notMatches("class A {};", TypeA));
159
160  TypeMatcher TypeAHasClassB = hasDeclaration(
161    recordDecl(hasName("A"), has(recordDecl(hasName("B")))));
162
163  EXPECT_TRUE(
164    matches("class A { public: A *a; class B {}; };", TypeAHasClassB));
165
166  EXPECT_TRUE(matchesC("struct S {}; void f(void) { struct S s; }",
167                       varDecl(hasType(namedDecl(hasName("S"))))));
168}
169
170TEST(TypeMatcher, MatchesDeclTypes) {
171  // TypedefType -> TypedefNameDecl
172  EXPECT_TRUE(matches("typedef int I; void f(I i);",
173                      parmVarDecl(hasType(namedDecl(hasName("I"))))));
174  // ObjCObjectPointerType
175  EXPECT_TRUE(matchesObjC("@interface Foo @end void f(Foo *f);",
176                          parmVarDecl(hasType(objcObjectPointerType()))));
177  // ObjCObjectPointerType -> ObjCInterfaceType -> ObjCInterfaceDecl
178  EXPECT_TRUE(matchesObjC(
179    "@interface Foo @end void f(Foo *f);",
180    parmVarDecl(hasType(pointsTo(objcInterfaceDecl(hasName("Foo")))))));
181  // TemplateTypeParmType
182  EXPECT_TRUE(matches("template <typename T> void f(T t);",
183                      parmVarDecl(hasType(templateTypeParmType()))));
184  // TemplateTypeParmType -> TemplateTypeParmDecl
185  EXPECT_TRUE(matches("template <typename T> void f(T t);",
186                      parmVarDecl(hasType(namedDecl(hasName("T"))))));
187  // InjectedClassNameType
188  EXPECT_TRUE(matches("template <typename T> struct S {"
189                        "  void f(S s);"
190                        "};",
191                      parmVarDecl(hasType(injectedClassNameType()))));
192  EXPECT_TRUE(notMatches("template <typename T> struct S {"
193                           "  void g(S<T> s);"
194                           "};",
195                         parmVarDecl(hasType(injectedClassNameType()))));
196  // InjectedClassNameType -> CXXRecordDecl
197  EXPECT_TRUE(matches("template <typename T> struct S {"
198                        "  void f(S s);"
199                        "};",
200                      parmVarDecl(hasType(namedDecl(hasName("S"))))));
201
202  static const char Using[] = "template <typename T>"
203    "struct Base {"
204    "  typedef T Foo;"
205    "};"
206    ""
207    "template <typename T>"
208    "struct S : private Base<T> {"
209    "  using typename Base<T>::Foo;"
210    "  void f(Foo);"
211    "};";
212  // UnresolvedUsingTypenameDecl
213  EXPECT_TRUE(matches(Using, unresolvedUsingTypenameDecl(hasName("Foo"))));
214  // UnresolvedUsingTypenameType -> UnresolvedUsingTypenameDecl
215  EXPECT_TRUE(matches(Using, parmVarDecl(hasType(namedDecl(hasName("Foo"))))));
216}
217
218TEST(HasDeclaration, HasDeclarationOfEnumType) {
219  EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
220                      expr(hasType(pointsTo(
221                        qualType(hasDeclaration(enumDecl(hasName("X")))))))));
222}
223
224TEST(HasDeclaration, HasGetDeclTraitTest) {
225  EXPECT_TRUE(internal::has_getDecl<TypedefType>::value);
226  EXPECT_TRUE(internal::has_getDecl<RecordType>::value);
227  EXPECT_FALSE(internal::has_getDecl<TemplateSpecializationType>::value);
228}
229
230TEST(HasDeclaration, HasDeclarationOfTypeWithDecl) {
231  EXPECT_TRUE(matches("typedef int X; X a;",
232                      varDecl(hasName("a"),
233                              hasType(typedefType(hasDeclaration(decl()))))));
234
235  // FIXME: Add tests for other types with getDecl() (e.g. RecordType)
236}
237
238TEST(HasDeclaration, HasDeclarationOfTemplateSpecializationType) {
239  EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
240                      varDecl(hasType(templateSpecializationType(
241                        hasDeclaration(namedDecl(hasName("A"))))))));
242}
243
244TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
245  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
246  EXPECT_TRUE(
247    matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
248  EXPECT_TRUE(
249    notMatches("class X {}; void y(X *x) { x; }",
250               expr(hasType(ClassX))));
251  EXPECT_TRUE(
252    matches("class X {}; void y(X *x) { x; }",
253            expr(hasType(pointsTo(ClassX)))));
254}
255
256TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
257  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
258  EXPECT_TRUE(
259    matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
260  EXPECT_TRUE(
261    notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
262  EXPECT_TRUE(
263    matches("class X {}; void y() { X *x; }",
264            varDecl(hasType(pointsTo(ClassX)))));
265}
266
267TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
268  DeclarationMatcher ClassX = recordDecl(hasName("X"));
269  EXPECT_TRUE(
270    matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
271  EXPECT_TRUE(
272    notMatches("class X {}; void y(X *x) { x; }",
273               expr(hasType(ClassX))));
274}
275
276TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
277  DeclarationMatcher ClassX = recordDecl(hasName("X"));
278  EXPECT_TRUE(
279    matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
280  EXPECT_TRUE(
281    notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
282}
283
284TEST(HasType, MatchesTypedefDecl) {
285  EXPECT_TRUE(matches("typedef int X;", typedefDecl(hasType(asString("int")))));
286  EXPECT_TRUE(matches("typedef const int T;",
287                      typedefDecl(hasType(asString("const int")))));
288  EXPECT_TRUE(notMatches("typedef const int T;",
289                         typedefDecl(hasType(asString("int")))));
290  EXPECT_TRUE(matches("typedef int foo; typedef foo bar;",
291                      typedefDecl(hasType(asString("foo")), hasName("bar"))));
292}
293
294TEST(HasType, MatchesTypedefNameDecl) {
295  EXPECT_TRUE(matches("using X = int;", typedefNameDecl(hasType(asString("int")))));
296  EXPECT_TRUE(matches("using T = const int;",
297                      typedefNameDecl(hasType(asString("const int")))));
298  EXPECT_TRUE(notMatches("using T = const int;",
299                         typedefNameDecl(hasType(asString("int")))));
300  EXPECT_TRUE(matches("using foo = int; using bar = foo;",
301                      typedefNameDecl(hasType(asString("foo")), hasName("bar"))));
302}
303
304TEST(HasTypeLoc, MatchesDeclaratorDecls) {
305  EXPECT_TRUE(matches("int x;",
306                      varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
307
308  // Make sure we don't crash on implicit constructors.
309  EXPECT_TRUE(notMatches("class X {}; X x;",
310                         declaratorDecl(hasTypeLoc(loc(asString("int"))))));
311}
312
313
314TEST(Callee, MatchesDeclarations) {
315  StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x"))));
316
317  EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
318  EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
319
320  CallMethodX = callExpr(callee(cxxConversionDecl()));
321  EXPECT_TRUE(
322    matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
323  EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
324                         CallMethodX));
325}
326
327TEST(Callee, MatchesMemberExpressions) {
328  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
329                      callExpr(callee(memberExpr()))));
330  EXPECT_TRUE(
331    notMatches("class Y { void x() { this->x(); } };", callExpr(callee(callExpr()))));
332}
333
334TEST(Matcher, Argument) {
335  StatementMatcher CallArgumentY = callExpr(
336    hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
337
338  EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
339  EXPECT_TRUE(
340    matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
341  EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
342
343  StatementMatcher WrongIndex = callExpr(
344    hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
345  EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
346}
347
348TEST(Matcher, AnyArgument) {
349  StatementMatcher CallArgumentY = callExpr(
350    hasAnyArgument(
351      ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("y")))))));
352  EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
353  EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
354  EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
355
356  StatementMatcher ImplicitCastedArgument = callExpr(
357    hasAnyArgument(implicitCastExpr()));
358  EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
359}
360
361TEST(ForEachArgumentWithParam, ReportsNoFalsePositives) {
362  StatementMatcher ArgumentY =
363    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
364  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
365  StatementMatcher CallExpr =
366    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
367
368  // IntParam does not match.
369  EXPECT_TRUE(notMatches("void f(int* i) { int* y; f(y); }", CallExpr));
370  // ArgumentY does not match.
371  EXPECT_TRUE(notMatches("void f(int i) { int x; f(x); }", CallExpr));
372}
373
374TEST(ForEachArgumentWithParam, MatchesCXXMemberCallExpr) {
375  StatementMatcher ArgumentY =
376    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
377  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
378  StatementMatcher CallExpr =
379    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
380  EXPECT_TRUE(matchAndVerifyResultTrue(
381    "struct S {"
382      "  const S& operator[](int i) { return *this; }"
383      "};"
384      "void f(S S1) {"
385      "  int y = 1;"
386      "  S1[y];"
387      "}",
388    CallExpr, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
389
390  StatementMatcher CallExpr2 =
391    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
392  EXPECT_TRUE(matchAndVerifyResultTrue(
393    "struct S {"
394      "  static void g(int i);"
395      "};"
396      "void f() {"
397      "  int y = 1;"
398      "  S::g(y);"
399      "}",
400    CallExpr2, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
401}
402
403TEST(ForEachArgumentWithParam, MatchesCallExpr) {
404  StatementMatcher ArgumentY =
405    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
406  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
407  StatementMatcher CallExpr =
408    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
409
410  EXPECT_TRUE(
411    matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
412                             llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>(
413                               "param")));
414  EXPECT_TRUE(
415    matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
416                             llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>(
417                               "arg")));
418
419  EXPECT_TRUE(matchAndVerifyResultTrue(
420    "void f(int i, int j) { int y; f(y, y); }", CallExpr,
421    llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 2)));
422  EXPECT_TRUE(matchAndVerifyResultTrue(
423    "void f(int i, int j) { int y; f(y, y); }", CallExpr,
424    llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
425}
426
427TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
428  StatementMatcher ArgumentY =
429    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
430  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
431  StatementMatcher ConstructExpr =
432    cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam));
433
434  EXPECT_TRUE(matchAndVerifyResultTrue(
435    "struct C {"
436      "  C(int i) {}"
437      "};"
438      "int y = 0;"
439      "C Obj(y);",
440    ConstructExpr,
441    llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param")));
442}
443
444TEST(ForEachArgumentWithParam, HandlesBoundNodesForNonMatches) {
445  EXPECT_TRUE(matchAndVerifyResultTrue(
446    "void g(int i, int j) {"
447      "  int a;"
448      "  int b;"
449      "  int c;"
450      "  g(a, 0);"
451      "  g(a, b);"
452      "  g(0, b);"
453      "}",
454    functionDecl(
455      forEachDescendant(varDecl().bind("v")),
456      forEachDescendant(callExpr(forEachArgumentWithParam(
457        declRefExpr(to(decl(equalsBoundNode("v")))), parmVarDecl())))),
458    llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
459}
460
461TEST(QualType, hasCanonicalType) {
462  EXPECT_TRUE(notMatches("typedef int &int_ref;"
463                           "int a;"
464                           "int_ref b = a;",
465                         varDecl(hasType(qualType(referenceType())))));
466  EXPECT_TRUE(
467    matches("typedef int &int_ref;"
468              "int a;"
469              "int_ref b = a;",
470            varDecl(hasType(qualType(hasCanonicalType(referenceType()))))));
471}
472
473TEST(HasParameter, CallsInnerMatcher) {
474  EXPECT_TRUE(matches("class X { void x(int) {} };",
475                      cxxMethodDecl(hasParameter(0, varDecl()))));
476  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
477                         cxxMethodDecl(hasParameter(0, hasName("x")))));
478}
479
480TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
481  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
482                         cxxMethodDecl(hasParameter(42, varDecl()))));
483}
484
485TEST(HasType, MatchesParameterVariableTypesStrictly) {
486  EXPECT_TRUE(matches(
487    "class X { void x(X x) {} };",
488    cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
489  EXPECT_TRUE(notMatches(
490    "class X { void x(const X &x) {} };",
491    cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
492  EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
493                      cxxMethodDecl(hasParameter(
494                        0, hasType(pointsTo(recordDecl(hasName("X"))))))));
495  EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
496                      cxxMethodDecl(hasParameter(
497                        0, hasType(references(recordDecl(hasName("X"))))))));
498}
499
500TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
501  EXPECT_TRUE(matches(
502    "class Y {}; class X { void x(X x, Y y) {} };",
503    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
504  EXPECT_TRUE(matches(
505    "class Y {}; class X { void x(Y y, X x) {} };",
506    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
507}
508
509TEST(Returns, MatchesReturnTypes) {
510  EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
511                      functionDecl(returns(asString("int")))));
512  EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
513                         functionDecl(returns(asString("float")))));
514  EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
515                      functionDecl(returns(hasDeclaration(
516                        recordDecl(hasName("Y")))))));
517}
518
519TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
520  EXPECT_TRUE(notMatches(
521    "class Y {}; class X { void x(int) {} };",
522    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
523}
524
525TEST(HasAnyParameter, DoesNotMatchThisPointer) {
526  EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
527                         cxxMethodDecl(hasAnyParameter(
528                           hasType(pointsTo(recordDecl(hasName("X"))))))));
529}
530
531TEST(HasName, MatchesParameterVariableDeclarations) {
532  EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
533                      cxxMethodDecl(hasAnyParameter(hasName("x")))));
534  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
535                         cxxMethodDecl(hasAnyParameter(hasName("x")))));
536}
537
538TEST(Matcher, MatchesTypeTemplateArgument) {
539  EXPECT_TRUE(matches(
540    "template<typename T> struct B {};"
541      "B<int> b;",
542    classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
543      asString("int"))))));
544}
545
546TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
547  EXPECT_TRUE(matches(
548    "struct B { int next; };"
549      "template<int(B::*next_ptr)> struct A {};"
550      "A<&B::next> a;",
551    classTemplateSpecializationDecl(hasAnyTemplateArgument(
552      refersToDeclaration(fieldDecl(hasName("next")))))));
553
554  EXPECT_TRUE(notMatches(
555    "template <typename T> struct A {};"
556      "A<int> a;",
557    classTemplateSpecializationDecl(hasAnyTemplateArgument(
558      refersToDeclaration(decl())))));
559
560  EXPECT_TRUE(matches(
561    "struct B { int next; };"
562      "template<int(B::*next_ptr)> struct A {};"
563      "A<&B::next> a;",
564    templateSpecializationType(hasAnyTemplateArgument(isExpr(
565      hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))));
566
567  EXPECT_TRUE(notMatches(
568    "template <typename T> struct A {};"
569      "A<int> a;",
570    templateSpecializationType(hasAnyTemplateArgument(
571      refersToDeclaration(decl())))));
572}
573
574
575TEST(Matcher, MatchesSpecificArgument) {
576  EXPECT_TRUE(matches(
577    "template<typename T, typename U> class A {};"
578      "A<bool, int> a;",
579    classTemplateSpecializationDecl(hasTemplateArgument(
580      1, refersToType(asString("int"))))));
581  EXPECT_TRUE(notMatches(
582    "template<typename T, typename U> class A {};"
583      "A<int, bool> a;",
584    classTemplateSpecializationDecl(hasTemplateArgument(
585      1, refersToType(asString("int"))))));
586
587  EXPECT_TRUE(matches(
588    "template<typename T, typename U> class A {};"
589      "A<bool, int> a;",
590    templateSpecializationType(hasTemplateArgument(
591      1, refersToType(asString("int"))))));
592  EXPECT_TRUE(notMatches(
593    "template<typename T, typename U> class A {};"
594      "A<int, bool> a;",
595    templateSpecializationType(hasTemplateArgument(
596      1, refersToType(asString("int"))))));
597}
598
599TEST(TemplateArgument, Matches) {
600  EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
601                      classTemplateSpecializationDecl(
602                        hasAnyTemplateArgument(templateArgument()))));
603  EXPECT_TRUE(matches(
604    "template<typename T> struct C {}; C<int> c;",
605    templateSpecializationType(hasAnyTemplateArgument(templateArgument()))));
606}
607
608TEST(RefersToIntegralType, Matches) {
609  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
610                      classTemplateSpecializationDecl(
611                        hasAnyTemplateArgument(refersToIntegralType(
612                          asString("int"))))));
613  EXPECT_TRUE(notMatches("template<unsigned T> struct C {}; C<42> c;",
614                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
615                           refersToIntegralType(asString("int"))))));
616}
617
618TEST(ConstructorDeclaration, SimpleCase) {
619  EXPECT_TRUE(matches("class Foo { Foo(int i); };",
620                      cxxConstructorDecl(ofClass(hasName("Foo")))));
621  EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
622                         cxxConstructorDecl(ofClass(hasName("Bar")))));
623}
624
625TEST(DestructorDeclaration, MatchesVirtualDestructor) {
626  EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
627                      cxxDestructorDecl(ofClass(hasName("Foo")))));
628}
629
630TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {
631  EXPECT_TRUE(notMatches("class Foo {};",
632                         cxxDestructorDecl(ofClass(hasName("Foo")))));
633}
634
635TEST(HasAnyConstructorInitializer, SimpleCase) {
636  EXPECT_TRUE(
637    notMatches("class Foo { Foo() { } };",
638               cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
639  EXPECT_TRUE(
640    matches("class Foo {"
641              "  Foo() : foo_() { }"
642              "  int foo_;"
643              "};",
644            cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
645}
646
647TEST(HasAnyConstructorInitializer, ForField) {
648  static const char Code[] =
649    "class Baz { };"
650      "class Foo {"
651      "  Foo() : foo_() { }"
652      "  Baz foo_;"
653      "  Baz bar_;"
654      "};";
655  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
656    forField(hasType(recordDecl(hasName("Baz"))))))));
657  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
658    forField(hasName("foo_"))))));
659  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
660    forField(hasType(recordDecl(hasName("Bar"))))))));
661}
662
663TEST(HasAnyConstructorInitializer, WithInitializer) {
664  static const char Code[] =
665    "class Foo {"
666      "  Foo() : foo_(0) { }"
667      "  int foo_;"
668      "};";
669  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
670    withInitializer(integerLiteral(equals(0)))))));
671  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
672    withInitializer(integerLiteral(equals(1)))))));
673}
674
675TEST(HasAnyConstructorInitializer, IsWritten) {
676  static const char Code[] =
677    "struct Bar { Bar(){} };"
678      "class Foo {"
679      "  Foo() : foo_() { }"
680      "  Bar foo_;"
681      "  Bar bar_;"
682      "};";
683  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
684    allOf(forField(hasName("foo_")), isWritten())))));
685  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
686    allOf(forField(hasName("bar_")), isWritten())))));
687  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
688    allOf(forField(hasName("bar_")), unless(isWritten()))))));
689}
690
691TEST(HasAnyConstructorInitializer, IsBaseInitializer) {
692  static const char Code[] =
693    "struct B {};"
694      "struct D : B {"
695      "  int I;"
696      "  D(int i) : I(i) {}"
697      "};"
698      "struct E : B {"
699      "  E() : B() {}"
700      "};";
701  EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
702    hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
703    hasName("E")))));
704  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
705    hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
706    hasName("D")))));
707  EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
708    hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
709    hasName("D")))));
710  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
711    hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
712    hasName("E")))));
713}
714
715TEST(IfStmt, ChildTraversalMatchers) {
716  EXPECT_TRUE(matches("void f() { if (false) true; else false; }",
717                      ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
718  EXPECT_TRUE(notMatches("void f() { if (false) false; else true; }",
719                         ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
720  EXPECT_TRUE(matches("void f() { if (false) false; else true; }",
721                      ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
722  EXPECT_TRUE(notMatches("void f() { if (false) true; else false; }",
723                         ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
724}
725
726TEST(MatchBinaryOperator, HasOperatorName) {
727  StatementMatcher OperatorOr = binaryOperator(hasOperatorName("||"));
728
729  EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
730  EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
731}
732
733TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
734  StatementMatcher OperatorTrueFalse =
735    binaryOperator(hasLHS(cxxBoolLiteral(equals(true))),
736                   hasRHS(cxxBoolLiteral(equals(false))));
737
738  EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
739  EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
740  EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
741
742  StatementMatcher OperatorIntPointer = arraySubscriptExpr(
743    hasLHS(hasType(isInteger())), hasRHS(hasType(pointsTo(qualType()))));
744  EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
745  EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
746}
747
748TEST(MatchBinaryOperator, HasEitherOperand) {
749  StatementMatcher HasOperand =
750    binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false))));
751
752  EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
753  EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
754  EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
755}
756
757TEST(Matcher, BinaryOperatorTypes) {
758  // Integration test that verifies the AST provides all binary operators in
759  // a way we expect.
760  // FIXME: Operator ','
761  EXPECT_TRUE(
762    matches("void x() { 3, 4; }", binaryOperator(hasOperatorName(","))));
763  EXPECT_TRUE(
764    matches("bool b; bool c = (b = true);",
765            binaryOperator(hasOperatorName("="))));
766  EXPECT_TRUE(
767    matches("bool b = 1 != 2;", binaryOperator(hasOperatorName("!="))));
768  EXPECT_TRUE(
769    matches("bool b = 1 == 2;", binaryOperator(hasOperatorName("=="))));
770  EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
771  EXPECT_TRUE(
772    matches("bool b = 1 <= 2;", binaryOperator(hasOperatorName("<="))));
773  EXPECT_TRUE(
774    matches("int i = 1 << 2;", binaryOperator(hasOperatorName("<<"))));
775  EXPECT_TRUE(
776    matches("int i = 1; int j = (i <<= 2);",
777            binaryOperator(hasOperatorName("<<="))));
778  EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
779  EXPECT_TRUE(
780    matches("bool b = 1 >= 2;", binaryOperator(hasOperatorName(">="))));
781  EXPECT_TRUE(
782    matches("int i = 1 >> 2;", binaryOperator(hasOperatorName(">>"))));
783  EXPECT_TRUE(
784    matches("int i = 1; int j = (i >>= 2);",
785            binaryOperator(hasOperatorName(">>="))));
786  EXPECT_TRUE(
787    matches("int i = 42 ^ 23;", binaryOperator(hasOperatorName("^"))));
788  EXPECT_TRUE(
789    matches("int i = 42; int j = (i ^= 42);",
790            binaryOperator(hasOperatorName("^="))));
791  EXPECT_TRUE(
792    matches("int i = 42 % 23;", binaryOperator(hasOperatorName("%"))));
793  EXPECT_TRUE(
794    matches("int i = 42; int j = (i %= 42);",
795            binaryOperator(hasOperatorName("%="))));
796  EXPECT_TRUE(
797    matches("bool b = 42  &23;", binaryOperator(hasOperatorName("&"))));
798  EXPECT_TRUE(
799    matches("bool b = true && false;",
800            binaryOperator(hasOperatorName("&&"))));
801  EXPECT_TRUE(
802    matches("bool b = true; bool c = (b &= false);",
803            binaryOperator(hasOperatorName("&="))));
804  EXPECT_TRUE(
805    matches("bool b = 42 | 23;", binaryOperator(hasOperatorName("|"))));
806  EXPECT_TRUE(
807    matches("bool b = true || false;",
808            binaryOperator(hasOperatorName("||"))));
809  EXPECT_TRUE(
810    matches("bool b = true; bool c = (b |= false);",
811            binaryOperator(hasOperatorName("|="))));
812  EXPECT_TRUE(
813    matches("int i = 42  *23;", binaryOperator(hasOperatorName("*"))));
814  EXPECT_TRUE(
815    matches("int i = 42; int j = (i *= 23);",
816            binaryOperator(hasOperatorName("*="))));
817  EXPECT_TRUE(
818    matches("int i = 42 / 23;", binaryOperator(hasOperatorName("/"))));
819  EXPECT_TRUE(
820    matches("int i = 42; int j = (i /= 23);",
821            binaryOperator(hasOperatorName("/="))));
822  EXPECT_TRUE(
823    matches("int i = 42 + 23;", binaryOperator(hasOperatorName("+"))));
824  EXPECT_TRUE(
825    matches("int i = 42; int j = (i += 23);",
826            binaryOperator(hasOperatorName("+="))));
827  EXPECT_TRUE(
828    matches("int i = 42 - 23;", binaryOperator(hasOperatorName("-"))));
829  EXPECT_TRUE(
830    matches("int i = 42; int j = (i -= 23);",
831            binaryOperator(hasOperatorName("-="))));
832  EXPECT_TRUE(
833    matches("struct A { void x() { void (A::*a)(); (this->*a)(); } };",
834            binaryOperator(hasOperatorName("->*"))));
835  EXPECT_TRUE(
836    matches("struct A { void x() { void (A::*a)(); ((*this).*a)(); } };",
837            binaryOperator(hasOperatorName(".*"))));
838
839  // Member expressions as operators are not supported in matches.
840  EXPECT_TRUE(
841    notMatches("struct A { void x(A *a) { a->x(this); } };",
842               binaryOperator(hasOperatorName("->"))));
843
844  // Initializer assignments are not represented as operator equals.
845  EXPECT_TRUE(
846    notMatches("bool b = true;", binaryOperator(hasOperatorName("="))));
847
848  // Array indexing is not represented as operator.
849  EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));
850
851  // Overloaded operators do not match at all.
852  EXPECT_TRUE(notMatches(
853    "struct A { bool operator&&(const A &a) const { return false; } };"
854      "void x() { A a, b; a && b; }",
855    binaryOperator()));
856}
857
858TEST(MatchUnaryOperator, HasOperatorName) {
859  StatementMatcher OperatorNot = unaryOperator(hasOperatorName("!"));
860
861  EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
862  EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
863}
864
865TEST(MatchUnaryOperator, HasUnaryOperand) {
866  StatementMatcher OperatorOnFalse =
867    unaryOperator(hasUnaryOperand(cxxBoolLiteral(equals(false))));
868
869  EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
870  EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));
871}
872
873TEST(Matcher, UnaryOperatorTypes) {
874  // Integration test that verifies the AST provides all unary operators in
875  // a way we expect.
876  EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
877  EXPECT_TRUE(
878    matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
879  EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
880  EXPECT_TRUE(
881    matches("bool *p; bool b = *p;", unaryOperator(hasOperatorName("*"))));
882  EXPECT_TRUE(
883    matches("int i; int j = +i;", unaryOperator(hasOperatorName("+"))));
884  EXPECT_TRUE(
885    matches("int i; int j = -i;", unaryOperator(hasOperatorName("-"))));
886  EXPECT_TRUE(
887    matches("int i; int j = ++i;", unaryOperator(hasOperatorName("++"))));
888  EXPECT_TRUE(
889    matches("int i; int j = i++;", unaryOperator(hasOperatorName("++"))));
890  EXPECT_TRUE(
891    matches("int i; int j = --i;", unaryOperator(hasOperatorName("--"))));
892  EXPECT_TRUE(
893    matches("int i; int j = i--;", unaryOperator(hasOperatorName("--"))));
894
895  // We don't match conversion operators.
896  EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));
897
898  // Function calls are not represented as operator.
899  EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));
900
901  // Overloaded operators do not match at all.
902  // FIXME: We probably want to add that.
903  EXPECT_TRUE(notMatches(
904    "struct A { bool operator!() const { return false; } };"
905      "void x() { A a; !a; }", unaryOperator(hasOperatorName("!"))));
906}
907
908TEST(ArraySubscriptMatchers, ArrayIndex) {
909  EXPECT_TRUE(matches(
910    "int i[2]; void f() { i[1] = 1; }",
911    arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
912  EXPECT_TRUE(matches(
913    "int i[2]; void f() { 1[i] = 1; }",
914    arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
915  EXPECT_TRUE(notMatches(
916    "int i[2]; void f() { i[1] = 1; }",
917    arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
918}
919
920TEST(ArraySubscriptMatchers, MatchesArrayBase) {
921  EXPECT_TRUE(matches(
922    "int i[2]; void f() { i[1] = 2; }",
923    arraySubscriptExpr(hasBase(implicitCastExpr(
924      hasSourceExpression(declRefExpr()))))));
925}
926
927TEST(Matcher, OfClass) {
928  StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
929    ofClass(hasName("X")))));
930
931  EXPECT_TRUE(
932    matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
933  EXPECT_TRUE(
934    matches("class X { public: X(); }; void x(int) { X x = X(); }",
935            Constructor));
936  EXPECT_TRUE(
937    notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
938               Constructor));
939}
940
941TEST(Matcher, VisitsTemplateInstantiations) {
942  EXPECT_TRUE(matches(
943    "class A { public: void x(); };"
944      "template <typename T> class B { public: void y() { T t; t.x(); } };"
945      "void f() { B<A> b; b.y(); }",
946    callExpr(callee(cxxMethodDecl(hasName("x"))))));
947
948  EXPECT_TRUE(matches(
949    "class A { public: void x(); };"
950      "class C {"
951      " public:"
952      "  template <typename T> class B { public: void y() { T t; t.x(); } };"
953      "};"
954      "void f() {"
955      "  C::B<A> b; b.y();"
956      "}",
957    recordDecl(hasName("C"), hasDescendant(callExpr(
958      callee(cxxMethodDecl(hasName("x"))))))));
959}
960
961TEST(Matcher, HasCondition) {
962  StatementMatcher IfStmt =
963    ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
964  EXPECT_TRUE(matches("void x() { if (true) {} }", IfStmt));
965  EXPECT_TRUE(notMatches("void x() { if (false) {} }", IfStmt));
966
967  StatementMatcher ForStmt =
968    forStmt(hasCondition(cxxBoolLiteral(equals(true))));
969  EXPECT_TRUE(matches("void x() { for (;true;) {} }", ForStmt));
970  EXPECT_TRUE(notMatches("void x() { for (;false;) {} }", ForStmt));
971
972  StatementMatcher WhileStmt =
973    whileStmt(hasCondition(cxxBoolLiteral(equals(true))));
974  EXPECT_TRUE(matches("void x() { while (true) {} }", WhileStmt));
975  EXPECT_TRUE(notMatches("void x() { while (false) {} }", WhileStmt));
976
977  StatementMatcher SwitchStmt =
978    switchStmt(hasCondition(integerLiteral(equals(42))));
979  EXPECT_TRUE(matches("void x() { switch (42) {case 42:;} }", SwitchStmt));
980  EXPECT_TRUE(notMatches("void x() { switch (43) {case 43:;} }", SwitchStmt));
981}
982
983TEST(For, ForLoopInternals) {
984  EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
985                      forStmt(hasCondition(anything()))));
986  EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
987                      forStmt(hasLoopInit(anything()))));
988}
989
990TEST(For, ForRangeLoopInternals) {
991  EXPECT_TRUE(matches("void f(){ int a[] {1, 2}; for (int i : a); }",
992                      cxxForRangeStmt(hasLoopVariable(anything()))));
993  EXPECT_TRUE(matches(
994    "void f(){ int a[] {1, 2}; for (int i : a); }",
995    cxxForRangeStmt(hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))))));
996}
997
998TEST(For, NegativeForLoopInternals) {
999  EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
1000                         forStmt(hasCondition(expr()))));
1001  EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
1002                         forStmt(hasLoopInit(anything()))));
1003}
1004
1005TEST(HasBody, FindsBodyOfForWhileDoLoops) {
1006  EXPECT_TRUE(matches("void f() { for(;;) {} }",
1007                      forStmt(hasBody(compoundStmt()))));
1008  EXPECT_TRUE(notMatches("void f() { for(;;); }",
1009                         forStmt(hasBody(compoundStmt()))));
1010  EXPECT_TRUE(matches("void f() { while(true) {} }",
1011                      whileStmt(hasBody(compoundStmt()))));
1012  EXPECT_TRUE(matches("void f() { do {} while(true); }",
1013                      doStmt(hasBody(compoundStmt()))));
1014  EXPECT_TRUE(matches("void f() { int p[2]; for (auto x : p) {} }",
1015                      cxxForRangeStmt(hasBody(compoundStmt()))));
1016  EXPECT_TRUE(matches("void f() {}", functionDecl(hasBody(compoundStmt()))));
1017  EXPECT_TRUE(notMatches("void f();", functionDecl(hasBody(compoundStmt()))));
1018  EXPECT_TRUE(matches("void f(); void f() {}",
1019                      functionDecl(hasBody(compoundStmt()))));
1020}
1021
1022TEST(HasAnySubstatement, MatchesForTopLevelCompoundStatement) {
1023  // The simplest case: every compound statement is in a function
1024  // definition, and the function body itself must be a compound
1025  // statement.
1026  EXPECT_TRUE(matches("void f() { for (;;); }",
1027                      compoundStmt(hasAnySubstatement(forStmt()))));
1028}
1029
1030TEST(HasAnySubstatement, IsNotRecursive) {
1031  // It's really "has any immediate substatement".
1032  EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
1033                         compoundStmt(hasAnySubstatement(forStmt()))));
1034}
1035
1036TEST(HasAnySubstatement, MatchesInNestedCompoundStatements) {
1037  EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
1038                      compoundStmt(hasAnySubstatement(forStmt()))));
1039}
1040
1041TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
1042  EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
1043                      compoundStmt(hasAnySubstatement(forStmt()))));
1044}
1045
1046TEST(Member, MatchesMemberAllocationFunction) {
1047  // Fails in C++11 mode
1048  EXPECT_TRUE(matchesConditionally(
1049    "namespace std { typedef typeof(sizeof(int)) size_t; }"
1050      "class X { void *operator new(std::size_t); };",
1051    cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
1052
1053  EXPECT_TRUE(matches("class X { void operator delete(void*); };",
1054                      cxxMethodDecl(ofClass(hasName("X")))));
1055
1056  // Fails in C++11 mode
1057  EXPECT_TRUE(matchesConditionally(
1058    "namespace std { typedef typeof(sizeof(int)) size_t; }"
1059      "class X { void operator delete[](void*, std::size_t); };",
1060    cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
1061}
1062
1063TEST(HasDestinationType, MatchesSimpleCase) {
1064  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1065                      cxxStaticCastExpr(hasDestinationType(
1066                        pointsTo(TypeMatcher(anything()))))));
1067}
1068
1069TEST(HasImplicitDestinationType, MatchesSimpleCase) {
1070  // This test creates an implicit const cast.
1071  EXPECT_TRUE(matches("int x; const int i = x;",
1072                      implicitCastExpr(
1073                        hasImplicitDestinationType(isInteger()))));
1074  // This test creates an implicit array-to-pointer cast.
1075  EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
1076                      implicitCastExpr(hasImplicitDestinationType(
1077                        pointsTo(TypeMatcher(anything()))))));
1078}
1079
1080TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
1081  // This test creates an implicit cast from int to char.
1082  EXPECT_TRUE(notMatches("char c = 0;",
1083                         implicitCastExpr(hasImplicitDestinationType(
1084                           unless(anything())))));
1085  // This test creates an implicit array-to-pointer cast.
1086  EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
1087                         implicitCastExpr(hasImplicitDestinationType(
1088                           unless(anything())))));
1089}
1090
1091TEST(IgnoringImplicit, MatchesImplicit) {
1092  EXPECT_TRUE(matches("class C {}; C a = C();",
1093                      varDecl(has(ignoringImplicit(cxxConstructExpr())))));
1094}
1095
1096TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
1097  EXPECT_TRUE(
1098      notMatches("class C {}; C a = C();", varDecl(has(cxxConstructExpr()))));
1099}
1100
1101TEST(IgnoringImpCasts, MatchesImpCasts) {
1102  // This test checks that ignoringImpCasts matches when implicit casts are
1103  // present and its inner matcher alone does not match.
1104  // Note that this test creates an implicit const cast.
1105  EXPECT_TRUE(matches("int x = 0; const int y = x;",
1106                      varDecl(hasInitializer(ignoringImpCasts(
1107                        declRefExpr(to(varDecl(hasName("x")))))))));
1108  // This test creates an implict cast from int to char.
1109  EXPECT_TRUE(matches("char x = 0;",
1110                      varDecl(hasInitializer(ignoringImpCasts(
1111                        integerLiteral(equals(0)))))));
1112}
1113
1114TEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
1115  // These tests verify that ignoringImpCasts does not match if the inner
1116  // matcher does not match.
1117  // Note that the first test creates an implicit const cast.
1118  EXPECT_TRUE(notMatches("int x; const int y = x;",
1119                         varDecl(hasInitializer(ignoringImpCasts(
1120                           unless(anything()))))));
1121  EXPECT_TRUE(notMatches("int x; int y = x;",
1122                         varDecl(hasInitializer(ignoringImpCasts(
1123                           unless(anything()))))));
1124
1125  // These tests verify that ignoringImplictCasts does not look through explicit
1126  // casts or parentheses.
1127  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1128                         varDecl(hasInitializer(ignoringImpCasts(
1129                           integerLiteral())))));
1130  EXPECT_TRUE(notMatches("int i = (0);",
1131                         varDecl(hasInitializer(ignoringImpCasts(
1132                           integerLiteral())))));
1133  EXPECT_TRUE(notMatches("float i = (float)0;",
1134                         varDecl(hasInitializer(ignoringImpCasts(
1135                           integerLiteral())))));
1136  EXPECT_TRUE(notMatches("float i = float(0);",
1137                         varDecl(hasInitializer(ignoringImpCasts(
1138                           integerLiteral())))));
1139}
1140
1141TEST(IgnoringImpCasts, MatchesWithoutImpCasts) {
1142  // This test verifies that expressions that do not have implicit casts
1143  // still match the inner matcher.
1144  EXPECT_TRUE(matches("int x = 0; int &y = x;",
1145                      varDecl(hasInitializer(ignoringImpCasts(
1146                        declRefExpr(to(varDecl(hasName("x")))))))));
1147}
1148
1149TEST(IgnoringParenCasts, MatchesParenCasts) {
1150  // This test checks that ignoringParenCasts matches when parentheses and/or
1151  // casts are present and its inner matcher alone does not match.
1152  EXPECT_TRUE(matches("int x = (0);",
1153                      varDecl(hasInitializer(ignoringParenCasts(
1154                        integerLiteral(equals(0)))))));
1155  EXPECT_TRUE(matches("int x = (((((0)))));",
1156                      varDecl(hasInitializer(ignoringParenCasts(
1157                        integerLiteral(equals(0)))))));
1158
1159  // This test creates an implict cast from int to char in addition to the
1160  // parentheses.
1161  EXPECT_TRUE(matches("char x = (0);",
1162                      varDecl(hasInitializer(ignoringParenCasts(
1163                        integerLiteral(equals(0)))))));
1164
1165  EXPECT_TRUE(matches("char x = (char)0;",
1166                      varDecl(hasInitializer(ignoringParenCasts(
1167                        integerLiteral(equals(0)))))));
1168  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1169                      varDecl(hasInitializer(ignoringParenCasts(
1170                        integerLiteral(equals(0)))))));
1171}
1172
1173TEST(IgnoringParenCasts, MatchesWithoutParenCasts) {
1174  // This test verifies that expressions that do not have any casts still match.
1175  EXPECT_TRUE(matches("int x = 0;",
1176                      varDecl(hasInitializer(ignoringParenCasts(
1177                        integerLiteral(equals(0)))))));
1178}
1179
1180TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) {
1181  // These tests verify that ignoringImpCasts does not match if the inner
1182  // matcher does not match.
1183  EXPECT_TRUE(notMatches("int x = ((0));",
1184                         varDecl(hasInitializer(ignoringParenCasts(
1185                           unless(anything()))))));
1186
1187  // This test creates an implicit cast from int to char in addition to the
1188  // parentheses.
1189  EXPECT_TRUE(notMatches("char x = ((0));",
1190                         varDecl(hasInitializer(ignoringParenCasts(
1191                           unless(anything()))))));
1192
1193  EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
1194                         varDecl(hasInitializer(ignoringParenCasts(
1195                           unless(anything()))))));
1196}
1197
1198TEST(IgnoringParenAndImpCasts, MatchesParenImpCasts) {
1199  // This test checks that ignoringParenAndImpCasts matches when
1200  // parentheses and/or implicit casts are present and its inner matcher alone
1201  // does not match.
1202  // Note that this test creates an implicit const cast.
1203  EXPECT_TRUE(matches("int x = 0; const int y = x;",
1204                      varDecl(hasInitializer(ignoringParenImpCasts(
1205                        declRefExpr(to(varDecl(hasName("x")))))))));
1206  // This test creates an implicit cast from int to char.
1207  EXPECT_TRUE(matches("const char x = (0);",
1208                      varDecl(hasInitializer(ignoringParenImpCasts(
1209                        integerLiteral(equals(0)))))));
1210}
1211
1212TEST(IgnoringParenAndImpCasts, MatchesWithoutParenImpCasts) {
1213  // This test verifies that expressions that do not have parentheses or
1214  // implicit casts still match.
1215  EXPECT_TRUE(matches("int x = 0; int &y = x;",
1216                      varDecl(hasInitializer(ignoringParenImpCasts(
1217                        declRefExpr(to(varDecl(hasName("x")))))))));
1218  EXPECT_TRUE(matches("int x = 0;",
1219                      varDecl(hasInitializer(ignoringParenImpCasts(
1220                        integerLiteral(equals(0)))))));
1221}
1222
1223TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) {
1224  // These tests verify that ignoringParenImpCasts does not match if
1225  // the inner matcher does not match.
1226  // This test creates an implicit cast.
1227  EXPECT_TRUE(notMatches("char c = ((3));",
1228                         varDecl(hasInitializer(ignoringParenImpCasts(
1229                           unless(anything()))))));
1230  // These tests verify that ignoringParenAndImplictCasts does not look
1231  // through explicit casts.
1232  EXPECT_TRUE(notMatches("float y = (float(0));",
1233                         varDecl(hasInitializer(ignoringParenImpCasts(
1234                           integerLiteral())))));
1235  EXPECT_TRUE(notMatches("float y = (float)0;",
1236                         varDecl(hasInitializer(ignoringParenImpCasts(
1237                           integerLiteral())))));
1238  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1239                         varDecl(hasInitializer(ignoringParenImpCasts(
1240                           integerLiteral())))));
1241}
1242
1243TEST(HasSourceExpression, MatchesImplicitCasts) {
1244  EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
1245                        "void r() {string a_string; URL url = a_string; }",
1246                      implicitCastExpr(
1247                        hasSourceExpression(cxxConstructExpr()))));
1248}
1249
1250TEST(HasSourceExpression, MatchesExplicitCasts) {
1251  EXPECT_TRUE(matches("float x = static_cast<float>(42);",
1252                      explicitCastExpr(
1253                        hasSourceExpression(hasDescendant(
1254                          expr(integerLiteral()))))));
1255}
1256
1257TEST(UsingDeclaration, MatchesSpecificTarget) {
1258  EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
1259                      usingDecl(hasAnyUsingShadowDecl(
1260                        hasTargetDecl(functionDecl())))));
1261  EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
1262                         usingDecl(hasAnyUsingShadowDecl(
1263                           hasTargetDecl(functionDecl())))));
1264}
1265
1266TEST(UsingDeclaration, ThroughUsingDeclaration) {
1267  EXPECT_TRUE(matches(
1268    "namespace a { void f(); } using a::f; void g() { f(); }",
1269    declRefExpr(throughUsingDecl(anything()))));
1270  EXPECT_TRUE(notMatches(
1271    "namespace a { void f(); } using a::f; void g() { a::f(); }",
1272    declRefExpr(throughUsingDecl(anything()))));
1273}
1274
1275TEST(SingleDecl, IsSingleDecl) {
1276  StatementMatcher SingleDeclStmt =
1277    declStmt(hasSingleDecl(varDecl(hasInitializer(anything()))));
1278  EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
1279  EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
1280  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1281                         SingleDeclStmt));
1282}
1283
1284TEST(DeclStmt, ContainsDeclaration) {
1285  DeclarationMatcher MatchesInit = varDecl(hasInitializer(anything()));
1286
1287  EXPECT_TRUE(matches("void f() {int a = 4;}",
1288                      declStmt(containsDeclaration(0, MatchesInit))));
1289  EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
1290                      declStmt(containsDeclaration(0, MatchesInit),
1291                               containsDeclaration(1, MatchesInit))));
1292  unsigned WrongIndex = 42;
1293  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1294                         declStmt(containsDeclaration(WrongIndex,
1295                                                      MatchesInit))));
1296}
1297
1298TEST(SwitchCase, MatchesEachCase) {
1299  EXPECT_TRUE(notMatches("void x() { switch(42); }",
1300                         switchStmt(forEachSwitchCase(caseStmt()))));
1301  EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
1302                      switchStmt(forEachSwitchCase(caseStmt()))));
1303  EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
1304                      switchStmt(forEachSwitchCase(caseStmt()))));
1305  EXPECT_TRUE(notMatches(
1306    "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
1307    ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
1308  EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
1309                      switchStmt(forEachSwitchCase(
1310                        caseStmt(hasCaseConstant(integerLiteral()))))));
1311  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
1312                         switchStmt(forEachSwitchCase(
1313                           caseStmt(hasCaseConstant(integerLiteral()))))));
1314  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
1315                         switchStmt(forEachSwitchCase(
1316                           caseStmt(hasCaseConstant(integerLiteral()))))));
1317  EXPECT_TRUE(matchAndVerifyResultTrue(
1318    "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
1319    switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
1320    llvm::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
1321}
1322
1323TEST(ForEachConstructorInitializer, MatchesInitializers) {
1324  EXPECT_TRUE(matches(
1325    "struct X { X() : i(42), j(42) {} int i, j; };",
1326    cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
1327}
1328
1329TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
1330  EXPECT_TRUE(notMatches(
1331    "void x() { if(true) {} }",
1332    ifStmt(hasConditionVariableStatement(declStmt()))));
1333  EXPECT_TRUE(notMatches(
1334    "void x() { int x; if((x = 42)) {} }",
1335    ifStmt(hasConditionVariableStatement(declStmt()))));
1336}
1337
1338TEST(HasConditionVariableStatement, MatchesConditionVariables) {
1339  EXPECT_TRUE(matches(
1340    "void x() { if(int* a = 0) {} }",
1341    ifStmt(hasConditionVariableStatement(declStmt()))));
1342}
1343
1344TEST(ForEach, BindsOneNode) {
1345  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
1346                                       recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
1347                                       llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1348}
1349
1350TEST(ForEach, BindsMultipleNodes) {
1351  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
1352                                       recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
1353                                       llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 3)));
1354}
1355
1356TEST(ForEach, BindsRecursiveCombinations) {
1357  EXPECT_TRUE(matchAndVerifyResultTrue(
1358    "class C { class D { int x; int y; }; class E { int y; int z; }; };",
1359    recordDecl(hasName("C"),
1360               forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
1361    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1362}
1363
1364TEST(ForEachDescendant, BindsOneNode) {
1365  EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
1366                                       recordDecl(hasName("C"),
1367                                                  forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
1368                                       llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1369}
1370
1371TEST(ForEachDescendant, NestedForEachDescendant) {
1372  DeclarationMatcher m = recordDecl(
1373    isDefinition(), decl().bind("x"), hasName("C"));
1374  EXPECT_TRUE(matchAndVerifyResultTrue(
1375    "class A { class B { class C {}; }; };",
1376    recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
1377    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1378
1379  // Check that a partial match of 'm' that binds 'x' in the
1380  // first part of anyOf(m, anything()) will not overwrite the
1381  // binding created by the earlier binding in the hasDescendant.
1382  EXPECT_TRUE(matchAndVerifyResultTrue(
1383    "class A { class B { class C {}; }; };",
1384    recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
1385    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1386}
1387
1388TEST(ForEachDescendant, BindsMultipleNodes) {
1389  EXPECT_TRUE(matchAndVerifyResultTrue(
1390    "class C { class D { int x; int y; }; "
1391      "          class E { class F { int y; int z; }; }; };",
1392    recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
1393    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1394}
1395
1396TEST(ForEachDescendant, BindsRecursiveCombinations) {
1397  EXPECT_TRUE(matchAndVerifyResultTrue(
1398    "class C { class D { "
1399      "          class E { class F { class G { int y; int z; }; }; }; }; };",
1400    recordDecl(hasName("C"), forEachDescendant(recordDecl(
1401      forEachDescendant(fieldDecl().bind("f"))))),
1402    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 8)));
1403}
1404
1405TEST(ForEachDescendant, BindsCombinations) {
1406  EXPECT_TRUE(matchAndVerifyResultTrue(
1407    "void f() { if(true) {} if (true) {} while (true) {} if (true) {} while "
1408      "(true) {} }",
1409    compoundStmt(forEachDescendant(ifStmt().bind("if")),
1410                 forEachDescendant(whileStmt().bind("while"))),
1411    llvm::make_unique<VerifyIdIsBoundTo<IfStmt>>("if", 6)));
1412}
1413
1414TEST(Has, DoesNotDeleteBindings) {
1415  EXPECT_TRUE(matchAndVerifyResultTrue(
1416    "class X { int a; };", recordDecl(decl().bind("x"), has(fieldDecl())),
1417    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1418}
1419
1420TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
1421  // Those matchers cover all the cases where an inner matcher is called
1422  // and there is not a 1:1 relationship between the match of the outer
1423  // matcher and the match of the inner matcher.
1424  // The pattern to look for is:
1425  //   ... return InnerMatcher.matches(...); ...
1426  // In which case no special handling is needed.
1427  //
1428  // On the other hand, if there are multiple alternative matches
1429  // (for example forEach*) or matches might be discarded (for example has*)
1430  // the implementation must make sure that the discarded matches do not
1431  // affect the bindings.
1432  // When new such matchers are added, add a test here that:
1433  // - matches a simple node, and binds it as the first thing in the matcher:
1434  //     recordDecl(decl().bind("x"), hasName("X")))
1435  // - uses the matcher under test afterwards in a way that not the first
1436  //   alternative is matched; for anyOf, that means the first branch
1437  //   would need to return false; for hasAncestor, it means that not
1438  //   the direct parent matches the inner matcher.
1439
1440  EXPECT_TRUE(matchAndVerifyResultTrue(
1441    "class X { int y; };",
1442    recordDecl(
1443      recordDecl().bind("x"), hasName("::X"),
1444      anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
1445    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
1446  EXPECT_TRUE(matchAndVerifyResultTrue(
1447    "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
1448                              anyOf(unless(anything()), anything())),
1449    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
1450  EXPECT_TRUE(matchAndVerifyResultTrue(
1451    "template<typename T1, typename T2> class X {}; X<float, int> x;",
1452    classTemplateSpecializationDecl(
1453      decl().bind("x"),
1454      hasAnyTemplateArgument(refersToType(asString("int")))),
1455    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1456  EXPECT_TRUE(matchAndVerifyResultTrue(
1457    "class X { void f(); void g(); };",
1458    cxxRecordDecl(decl().bind("x"), hasMethod(hasName("g"))),
1459    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1460  EXPECT_TRUE(matchAndVerifyResultTrue(
1461    "class X { X() : a(1), b(2) {} double a; int b; };",
1462    recordDecl(decl().bind("x"),
1463               has(cxxConstructorDecl(
1464                 hasAnyConstructorInitializer(forField(hasName("b")))))),
1465    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1466  EXPECT_TRUE(matchAndVerifyResultTrue(
1467    "void x(int, int) { x(0, 42); }",
1468    callExpr(expr().bind("x"), hasAnyArgument(integerLiteral(equals(42)))),
1469    llvm::make_unique<VerifyIdIsBoundTo<Expr>>("x", 1)));
1470  EXPECT_TRUE(matchAndVerifyResultTrue(
1471    "void x(int, int y) {}",
1472    functionDecl(decl().bind("x"), hasAnyParameter(hasName("y"))),
1473    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1474  EXPECT_TRUE(matchAndVerifyResultTrue(
1475    "void x() { return; if (true) {} }",
1476    functionDecl(decl().bind("x"),
1477                 has(compoundStmt(hasAnySubstatement(ifStmt())))),
1478    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1479  EXPECT_TRUE(matchAndVerifyResultTrue(
1480    "namespace X { void b(int); void b(); }"
1481      "using X::b;",
1482    usingDecl(decl().bind("x"), hasAnyUsingShadowDecl(hasTargetDecl(
1483      functionDecl(parameterCountIs(1))))),
1484    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1485  EXPECT_TRUE(matchAndVerifyResultTrue(
1486    "class A{}; class B{}; class C : B, A {};",
1487    cxxRecordDecl(decl().bind("x"), isDerivedFrom("::A")),
1488    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1489  EXPECT_TRUE(matchAndVerifyResultTrue(
1490    "class A{}; typedef A B; typedef A C; typedef A D;"
1491      "class E : A {};",
1492    cxxRecordDecl(decl().bind("x"), isDerivedFrom("C")),
1493    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1494  EXPECT_TRUE(matchAndVerifyResultTrue(
1495    "class A { class B { void f() {} }; };",
1496    functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
1497    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1498  EXPECT_TRUE(matchAndVerifyResultTrue(
1499    "template <typename T> struct A { struct B {"
1500      "  void f() { if(true) {} }"
1501      "}; };"
1502      "void t() { A<int>::B b; b.f(); }",
1503    ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
1504    llvm::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
1505  EXPECT_TRUE(matchAndVerifyResultTrue(
1506    "class A {};",
1507    recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
1508    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1509  EXPECT_TRUE(matchAndVerifyResultTrue(
1510    "class A { A() : s(), i(42) {} const char *s; int i; };",
1511    cxxConstructorDecl(hasName("::A::A"), decl().bind("x"),
1512                       forEachConstructorInitializer(forField(hasName("i")))),
1513    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1514}
1515
1516TEST(ForEachDescendant, BindsCorrectNodes) {
1517  EXPECT_TRUE(matchAndVerifyResultTrue(
1518    "class C { void f(); int i; };",
1519    recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
1520    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("decl", 1)));
1521  EXPECT_TRUE(matchAndVerifyResultTrue(
1522    "class C { void f() {} int i; };",
1523    recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
1524    llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("decl", 1)));
1525}
1526
1527TEST(FindAll, BindsNodeOnMatch) {
1528  EXPECT_TRUE(matchAndVerifyResultTrue(
1529    "class A {};",
1530    recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
1531    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 1)));
1532}
1533
1534TEST(FindAll, BindsDescendantNodeOnMatch) {
1535  EXPECT_TRUE(matchAndVerifyResultTrue(
1536    "class A { int a; int b; };",
1537    recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
1538    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
1539}
1540
1541TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
1542  EXPECT_TRUE(matchAndVerifyResultTrue(
1543    "class A { int a; int b; };",
1544    recordDecl(hasName("::A"),
1545               findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
1546                                  fieldDecl().bind("v"))))),
1547    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("v", 3)));
1548
1549  EXPECT_TRUE(matchAndVerifyResultTrue(
1550    "class A { class B {}; class C {}; };",
1551    recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
1552    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 3)));
1553}
1554
1555TEST(HasAncenstor, MatchesDeclarationAncestors) {
1556  EXPECT_TRUE(matches(
1557    "class A { class B { class C {}; }; };",
1558    recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("A"))))));
1559}
1560
1561TEST(HasAncenstor, FailsIfNoAncestorMatches) {
1562  EXPECT_TRUE(notMatches(
1563    "class A { class B { class C {}; }; };",
1564    recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("X"))))));
1565}
1566
1567TEST(HasAncestor, MatchesDeclarationsThatGetVisitedLater) {
1568  EXPECT_TRUE(matches(
1569    "class A { class B { void f() { C c; } class C {}; }; };",
1570    varDecl(hasName("c"), hasType(recordDecl(hasName("C"),
1571                                             hasAncestor(recordDecl(hasName("A"))))))));
1572}
1573
1574TEST(HasAncenstor, MatchesStatementAncestors) {
1575  EXPECT_TRUE(matches(
1576    "void f() { if (true) { while (false) { 42; } } }",
1577    integerLiteral(equals(42), hasAncestor(ifStmt()))));
1578}
1579
1580TEST(HasAncestor, DrillsThroughDifferentHierarchies) {
1581  EXPECT_TRUE(matches(
1582    "void f() { if (true) { int x = 42; } }",
1583    integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
1584}
1585
1586TEST(HasAncestor, BindsRecursiveCombinations) {
1587  EXPECT_TRUE(matchAndVerifyResultTrue(
1588    "class C { class D { class E { class F { int y; }; }; }; };",
1589    fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
1590    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("r", 1)));
1591}
1592
1593TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
1594  EXPECT_TRUE(matchAndVerifyResultTrue(
1595    "class C { class D { class E { class F { int y; }; }; }; };",
1596    fieldDecl(hasAncestor(
1597      decl(
1598        hasDescendant(recordDecl(isDefinition(),
1599                                 hasAncestor(recordDecl())))
1600      ).bind("d")
1601    )),
1602    llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
1603}
1604
1605TEST(HasAncestor, MatchesClosestAncestor) {
1606  EXPECT_TRUE(matchAndVerifyResultTrue(
1607    "template <typename T> struct C {"
1608      "  void f(int) {"
1609      "    struct I { void g(T) { int x; } } i; i.g(42);"
1610      "  }"
1611      "};"
1612      "template struct C<int>;",
1613    varDecl(hasName("x"),
1614            hasAncestor(functionDecl(hasParameter(
1615              0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
1616    llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
1617}
1618
1619TEST(HasAncestor, MatchesInTemplateInstantiations) {
1620  EXPECT_TRUE(matches(
1621    "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
1622      "A<int>::B::C a;",
1623    fieldDecl(hasType(asString("int")),
1624              hasAncestor(recordDecl(hasName("A"))))));
1625}
1626
1627TEST(HasAncestor, MatchesInImplicitCode) {
1628  EXPECT_TRUE(matches(
1629    "struct X {}; struct A { A() {} X x; };",
1630    cxxConstructorDecl(
1631      hasAnyConstructorInitializer(withInitializer(expr(
1632        hasAncestor(recordDecl(hasName("A")))))))));
1633}
1634
1635TEST(HasParent, MatchesOnlyParent) {
1636  EXPECT_TRUE(matches(
1637    "void f() { if (true) { int x = 42; } }",
1638    compoundStmt(hasParent(ifStmt()))));
1639  EXPECT_TRUE(notMatches(
1640    "void f() { for (;;) { int x = 42; } }",
1641    compoundStmt(hasParent(ifStmt()))));
1642  EXPECT_TRUE(notMatches(
1643    "void f() { if (true) for (;;) { int x = 42; } }",
1644    compoundStmt(hasParent(ifStmt()))));
1645}
1646
1647TEST(HasAncestor, MatchesAllAncestors) {
1648  EXPECT_TRUE(matches(
1649    "template <typename T> struct C { static void f() { 42; } };"
1650      "void t() { C<int>::f(); }",
1651    integerLiteral(
1652      equals(42),
1653      allOf(
1654        hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
1655        hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
1656}
1657
1658TEST(HasAncestor, ImplicitArrayCopyCtorDeclRefExpr) {
1659  EXPECT_TRUE(matches("struct MyClass {\n"
1660                        "  int c[1];\n"
1661                        "  static MyClass Create() { return MyClass(); }\n"
1662                        "};",
1663                      declRefExpr(to(decl(hasAncestor(decl()))))));
1664}
1665
1666TEST(HasAncestor, AnonymousUnionMemberExpr) {
1667  EXPECT_TRUE(matches("int F() {\n"
1668                        "  union { int i; };\n"
1669                        "  return i;\n"
1670                        "}\n",
1671                      memberExpr(member(hasAncestor(decl())))));
1672  EXPECT_TRUE(matches("void f() {\n"
1673                        "  struct {\n"
1674                        "    struct { int a; int b; };\n"
1675                        "  } s;\n"
1676                        "  s.a = 4;\n"
1677                        "}\n",
1678                      memberExpr(member(hasAncestor(decl())))));
1679  EXPECT_TRUE(matches("void f() {\n"
1680                        "  struct {\n"
1681                        "    struct { int a; int b; };\n"
1682                        "  } s;\n"
1683                        "  s.a = 4;\n"
1684                        "}\n",
1685                      declRefExpr(to(decl(hasAncestor(decl()))))));
1686}
1687TEST(HasAncestor, NonParmDependentTemplateParmVarDeclRefExpr) {
1688  EXPECT_TRUE(matches("struct PartitionAllocator {\n"
1689                        "  template<typename T>\n"
1690                        "  static int quantizedSize(int count) {\n"
1691                        "    return count;\n"
1692                        "  }\n"
1693                        "  void f() { quantizedSize<int>(10); }\n"
1694                        "};",
1695                      declRefExpr(to(decl(hasAncestor(decl()))))));
1696}
1697
1698TEST(HasAncestor, AddressOfExplicitSpecializationFunction) {
1699  EXPECT_TRUE(matches("template <class T> void f();\n"
1700                        "template <> void f<int>();\n"
1701                        "void (*get_f())() { return f<int>; }\n",
1702                      declRefExpr(to(decl(hasAncestor(decl()))))));
1703}
1704
1705TEST(HasParent, MatchesAllParents) {
1706  EXPECT_TRUE(matches(
1707    "template <typename T> struct C { static void f() { 42; } };"
1708      "void t() { C<int>::f(); }",
1709    integerLiteral(
1710      equals(42),
1711      hasParent(compoundStmt(hasParent(functionDecl(
1712        hasParent(cxxRecordDecl(isTemplateInstantiation())))))))));
1713  EXPECT_TRUE(
1714    matches("template <typename T> struct C { static void f() { 42; } };"
1715              "void t() { C<int>::f(); }",
1716            integerLiteral(
1717              equals(42),
1718              hasParent(compoundStmt(hasParent(functionDecl(hasParent(
1719                cxxRecordDecl(unless(isTemplateInstantiation()))))))))));
1720  EXPECT_TRUE(matches(
1721    "template <typename T> struct C { static void f() { 42; } };"
1722      "void t() { C<int>::f(); }",
1723    integerLiteral(equals(42),
1724                   hasParent(compoundStmt(
1725                     allOf(hasParent(functionDecl(hasParent(
1726                       cxxRecordDecl(isTemplateInstantiation())))),
1727                           hasParent(functionDecl(hasParent(cxxRecordDecl(
1728                             unless(isTemplateInstantiation())))))))))));
1729  EXPECT_TRUE(
1730    notMatches("template <typename T> struct C { static void f() {} };"
1731                 "void t() { C<int>::f(); }",
1732               compoundStmt(hasParent(recordDecl()))));
1733}
1734
1735TEST(HasParent, NoDuplicateParents) {
1736  class HasDuplicateParents : public BoundNodesCallback {
1737  public:
1738    bool run(const BoundNodes *Nodes) override { return false; }
1739    bool run(const BoundNodes *Nodes, ASTContext *Context) override {
1740      const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
1741      std::set<const void *> Parents;
1742      for (const auto &Parent : Context->getParents(*Node)) {
1743        if (!Parents.insert(Parent.getMemoizationData()).second) {
1744          return true;
1745        }
1746      }
1747      return false;
1748    }
1749  };
1750  EXPECT_FALSE(matchAndVerifyResultTrue(
1751    "template <typename T> int Foo() { return 1 + 2; }\n"
1752      "int x = Foo<int>() + Foo<unsigned>();",
1753    stmt().bind("node"), llvm::make_unique<HasDuplicateParents>()));
1754}
1755
1756TEST(TypeMatching, PointeeTypes) {
1757  EXPECT_TRUE(matches("int b; int &a = b;",
1758                      referenceType(pointee(builtinType()))));
1759  EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));
1760
1761  EXPECT_TRUE(matches("int *a;",
1762                      loc(pointerType(pointee(builtinType())))));
1763
1764  EXPECT_TRUE(matches(
1765    "int const *A;",
1766    pointerType(pointee(isConstQualified(), builtinType()))));
1767  EXPECT_TRUE(notMatches(
1768    "int *A;",
1769    pointerType(pointee(isConstQualified(), builtinType()))));
1770}
1771
1772TEST(ElaboratedTypeNarrowing, hasQualifier) {
1773  EXPECT_TRUE(matches(
1774    "namespace N {"
1775      "  namespace M {"
1776      "    class D {};"
1777      "  }"
1778      "}"
1779      "N::M::D d;",
1780    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
1781  EXPECT_TRUE(notMatches(
1782    "namespace M {"
1783      "  class D {};"
1784      "}"
1785      "M::D d;",
1786    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
1787  EXPECT_TRUE(notMatches(
1788    "struct D {"
1789      "} d;",
1790    elaboratedType(hasQualifier(nestedNameSpecifier()))));
1791}
1792
1793TEST(ElaboratedTypeNarrowing, namesType) {
1794  EXPECT_TRUE(matches(
1795    "namespace N {"
1796      "  namespace M {"
1797      "    class D {};"
1798      "  }"
1799      "}"
1800      "N::M::D d;",
1801    elaboratedType(elaboratedType(namesType(recordType(
1802      hasDeclaration(namedDecl(hasName("D")))))))));
1803  EXPECT_TRUE(notMatches(
1804    "namespace M {"
1805      "  class D {};"
1806      "}"
1807      "M::D d;",
1808    elaboratedType(elaboratedType(namesType(typedefType())))));
1809}
1810
1811TEST(NNS, BindsNestedNameSpecifiers) {
1812  EXPECT_TRUE(matchAndVerifyResultTrue(
1813    "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
1814    nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
1815    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
1816      "nns", "ns::struct E::")));
1817}
1818
1819TEST(NNS, BindsNestedNameSpecifierLocs) {
1820  EXPECT_TRUE(matchAndVerifyResultTrue(
1821    "namespace ns { struct B {}; } ns::B b;",
1822    loc(nestedNameSpecifier()).bind("loc"),
1823    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("loc", 1)));
1824}
1825
1826TEST(NNS, DescendantsOfNestedNameSpecifiers) {
1827  std::string Fragment =
1828    "namespace a { struct A { struct B { struct C {}; }; }; };"
1829      "void f() { a::A::B::C c; }";
1830  EXPECT_TRUE(matches(
1831    Fragment,
1832    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1833                        hasDescendant(nestedNameSpecifier(
1834                          specifiesNamespace(hasName("a")))))));
1835  EXPECT_TRUE(notMatches(
1836    Fragment,
1837    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1838                        has(nestedNameSpecifier(
1839                          specifiesNamespace(hasName("a")))))));
1840  EXPECT_TRUE(matches(
1841    Fragment,
1842    nestedNameSpecifier(specifiesType(asString("struct a::A")),
1843                        has(nestedNameSpecifier(
1844                          specifiesNamespace(hasName("a")))))));
1845
1846  // Not really useful because a NestedNameSpecifier can af at most one child,
1847  // but to complete the interface.
1848  EXPECT_TRUE(matchAndVerifyResultTrue(
1849    Fragment,
1850    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1851                        forEach(nestedNameSpecifier().bind("x"))),
1852    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 1)));
1853}
1854
1855TEST(NNS, NestedNameSpecifiersAsDescendants) {
1856  std::string Fragment =
1857    "namespace a { struct A { struct B { struct C {}; }; }; };"
1858      "void f() { a::A::B::C c; }";
1859  EXPECT_TRUE(matches(
1860    Fragment,
1861    decl(hasDescendant(nestedNameSpecifier(specifiesType(
1862      asString("struct a::A")))))));
1863  EXPECT_TRUE(matchAndVerifyResultTrue(
1864    Fragment,
1865    functionDecl(hasName("f"),
1866                 forEachDescendant(nestedNameSpecifier().bind("x"))),
1867    // Nested names: a, a::A and a::A::B.
1868    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 3)));
1869}
1870
1871TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
1872  std::string Fragment =
1873    "namespace a { struct A { struct B { struct C {}; }; }; };"
1874      "void f() { a::A::B::C c; }";
1875  EXPECT_TRUE(matches(
1876    Fragment,
1877    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1878                           hasDescendant(loc(nestedNameSpecifier(
1879                             specifiesNamespace(hasName("a"))))))));
1880  EXPECT_TRUE(notMatches(
1881    Fragment,
1882    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1883                           has(loc(nestedNameSpecifier(
1884                             specifiesNamespace(hasName("a"))))))));
1885  EXPECT_TRUE(matches(
1886    Fragment,
1887    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
1888                           has(loc(nestedNameSpecifier(
1889                             specifiesNamespace(hasName("a"))))))));
1890
1891  EXPECT_TRUE(matchAndVerifyResultTrue(
1892    Fragment,
1893    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1894                           forEach(nestedNameSpecifierLoc().bind("x"))),
1895    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 1)));
1896}
1897
1898TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
1899  std::string Fragment =
1900    "namespace a { struct A { struct B { struct C {}; }; }; };"
1901      "void f() { a::A::B::C c; }";
1902  EXPECT_TRUE(matches(
1903    Fragment,
1904    decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
1905      asString("struct a::A"))))))));
1906  EXPECT_TRUE(matchAndVerifyResultTrue(
1907    Fragment,
1908    functionDecl(hasName("f"),
1909                 forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
1910    // Nested names: a, a::A and a::A::B.
1911    llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 3)));
1912}
1913template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
1914public:
1915  VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
1916                    StringRef InnerId)
1917    : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
1918  }
1919
1920  bool run(const BoundNodes *Nodes) override { return false; }
1921
1922  bool run(const BoundNodes *Nodes, ASTContext *Context) override {
1923    const T *Node = Nodes->getNodeAs<T>(Id);
1924    return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context)) !=
1925      nullptr;
1926  }
1927private:
1928  std::string Id;
1929  internal::Matcher<T> InnerMatcher;
1930  std::string InnerId;
1931};
1932
1933TEST(MatchFinder, CanMatchDeclarationsRecursively) {
1934  EXPECT_TRUE(matchAndVerifyResultTrue(
1935    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1936    llvm::make_unique<VerifyMatchOnNode<Decl>>(
1937      "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
1938      "Y")));
1939  EXPECT_TRUE(matchAndVerifyResultFalse(
1940    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1941    llvm::make_unique<VerifyMatchOnNode<Decl>>(
1942      "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
1943      "Z")));
1944}
1945
1946TEST(MatchFinder, CanMatchStatementsRecursively) {
1947  EXPECT_TRUE(matchAndVerifyResultTrue(
1948    "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
1949    llvm::make_unique<VerifyMatchOnNode<Stmt>>(
1950      "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
1951  EXPECT_TRUE(matchAndVerifyResultFalse(
1952    "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
1953    llvm::make_unique<VerifyMatchOnNode<Stmt>>(
1954      "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
1955}
1956
1957TEST(MatchFinder, CanMatchSingleNodesRecursively) {
1958  EXPECT_TRUE(matchAndVerifyResultTrue(
1959    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1960    llvm::make_unique<VerifyMatchOnNode<Decl>>(
1961      "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
1962  EXPECT_TRUE(matchAndVerifyResultFalse(
1963    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1964    llvm::make_unique<VerifyMatchOnNode<Decl>>(
1965      "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
1966}
1967
1968TEST(StatementMatcher, HasReturnValue) {
1969  StatementMatcher RetVal = returnStmt(hasReturnValue(binaryOperator()));
1970  EXPECT_TRUE(matches("int F() { int a, b; return a + b; }", RetVal));
1971  EXPECT_FALSE(matches("int F() { int a; return a; }", RetVal));
1972  EXPECT_FALSE(matches("void F() { return; }", RetVal));
1973}
1974
1975TEST(StatementMatcher, ForFunction) {
1976  const auto CppString1 =
1977    "struct PosVec {"
1978      "  PosVec& operator=(const PosVec&) {"
1979      "    auto x = [] { return 1; };"
1980      "    return *this;"
1981      "  }"
1982      "};";
1983  const auto CppString2 =
1984    "void F() {"
1985      "  struct S {"
1986      "    void F2() {"
1987      "       return;"
1988      "    }"
1989      "  };"
1990      "}";
1991  EXPECT_TRUE(
1992    matches(
1993      CppString1,
1994      returnStmt(forFunction(hasName("operator=")),
1995                 has(unaryOperator(hasOperatorName("*"))))));
1996  EXPECT_TRUE(
1997    notMatches(
1998      CppString1,
1999      returnStmt(forFunction(hasName("operator=")),
2000                 has(integerLiteral()))));
2001  EXPECT_TRUE(
2002    matches(
2003      CppString1,
2004      returnStmt(forFunction(hasName("operator()")),
2005                 has(integerLiteral()))));
2006  EXPECT_TRUE(matches(CppString2, returnStmt(forFunction(hasName("F2")))));
2007  EXPECT_TRUE(notMatches(CppString2, returnStmt(forFunction(hasName("F")))));
2008}
2009
2010TEST(Matcher, ForEachOverriden) {
2011  const auto ForEachOverriddenInClass = [](const char *ClassName) {
2012    return cxxMethodDecl(ofClass(hasName(ClassName)), isVirtual(),
2013                         forEachOverridden(cxxMethodDecl().bind("overridden")))
2014        .bind("override");
2015  };
2016  static const char Code1[] = "class A { virtual void f(); };"
2017                              "class B : public A { void f(); };"
2018                              "class C : public B { void f(); };";
2019  // C::f overrides A::f.
2020  EXPECT_TRUE(matchAndVerifyResultTrue(
2021      Code1, ForEachOverriddenInClass("C"),
2022      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2023  EXPECT_TRUE(matchAndVerifyResultTrue(
2024      Code1, ForEachOverriddenInClass("C"),
2025      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2026                                                          1)));
2027  // B::f overrides A::f.
2028  EXPECT_TRUE(matchAndVerifyResultTrue(
2029      Code1, ForEachOverriddenInClass("B"),
2030      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2031  EXPECT_TRUE(matchAndVerifyResultTrue(
2032      Code1, ForEachOverriddenInClass("B"),
2033      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2034                                                          1)));
2035  // A::f overrides nothing.
2036  EXPECT_TRUE(notMatches(Code1, ForEachOverriddenInClass("A")));
2037
2038  static const char Code2[] =
2039      "class A1 { virtual void f(); };"
2040      "class A2 { virtual void f(); };"
2041      "class B : public A1, public A2 { void f(); };";
2042  // B::f overrides A1::f and A2::f. This produces two matches.
2043  EXPECT_TRUE(matchAndVerifyResultTrue(
2044      Code2, ForEachOverriddenInClass("B"),
2045      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 2)));
2046  EXPECT_TRUE(matchAndVerifyResultTrue(
2047      Code2, ForEachOverriddenInClass("B"),
2048      llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2049                                                          2)));
2050  // A1::f overrides nothing.
2051  EXPECT_TRUE(notMatches(Code2, ForEachOverriddenInClass("A1")));
2052}
2053
2054} // namespace ast_matchers
2055} // namespace clang
2056