1//===- unittest/Tooling/ASTMatchersTest.cpp - AST matcher 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
22#if GTEST_HAS_DEATH_TEST
23TEST(HasNameDeathTest, DiesOnEmptyName) {
24  ASSERT_DEBUG_DEATH({
25    DeclarationMatcher HasEmptyName = recordDecl(hasName(""));
26    EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
27  }, "");
28}
29
30TEST(HasNameDeathTest, DiesOnEmptyPattern) {
31  ASSERT_DEBUG_DEATH({
32      DeclarationMatcher HasEmptyName = recordDecl(matchesName(""));
33      EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
34    }, "");
35}
36
37TEST(IsDerivedFromDeathTest, DiesOnEmptyBaseName) {
38  ASSERT_DEBUG_DEATH({
39    DeclarationMatcher IsDerivedFromEmpty = recordDecl(isDerivedFrom(""));
40    EXPECT_TRUE(notMatches("class X {};", IsDerivedFromEmpty));
41  }, "");
42}
43#endif
44
45TEST(Finder, DynamicOnlyAcceptsSomeMatchers) {
46  MatchFinder Finder;
47  EXPECT_TRUE(Finder.addDynamicMatcher(decl(), nullptr));
48  EXPECT_TRUE(Finder.addDynamicMatcher(callExpr(), nullptr));
49  EXPECT_TRUE(Finder.addDynamicMatcher(constantArrayType(hasSize(42)),
50                                       nullptr));
51
52  // Do not accept non-toplevel matchers.
53  EXPECT_FALSE(Finder.addDynamicMatcher(isArrow(), nullptr));
54  EXPECT_FALSE(Finder.addDynamicMatcher(hasSize(2), nullptr));
55  EXPECT_FALSE(Finder.addDynamicMatcher(hasName("x"), nullptr));
56}
57
58TEST(Decl, MatchesDeclarations) {
59  EXPECT_TRUE(notMatches("", decl(usingDecl())));
60  EXPECT_TRUE(matches("namespace x { class X {}; } using x::X;",
61                      decl(usingDecl())));
62}
63
64TEST(NameableDeclaration, MatchesVariousDecls) {
65  DeclarationMatcher NamedX = namedDecl(hasName("X"));
66  EXPECT_TRUE(matches("typedef int X;", NamedX));
67  EXPECT_TRUE(matches("int X;", NamedX));
68  EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
69  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
70  EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
71  EXPECT_TRUE(matches("namespace X { }", NamedX));
72  EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
73
74  EXPECT_TRUE(notMatches("#define X 1", NamedX));
75}
76
77TEST(NameableDeclaration, REMatchesVariousDecls) {
78  DeclarationMatcher NamedX = namedDecl(matchesName("::X"));
79  EXPECT_TRUE(matches("typedef int Xa;", NamedX));
80  EXPECT_TRUE(matches("int Xb;", NamedX));
81  EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
82  EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
83  EXPECT_TRUE(matches("void foo() { int Xgh; }", NamedX));
84  EXPECT_TRUE(matches("namespace Xij { }", NamedX));
85  EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
86
87  EXPECT_TRUE(notMatches("#define Xkl 1", NamedX));
88
89  DeclarationMatcher StartsWithNo = namedDecl(matchesName("::no"));
90  EXPECT_TRUE(matches("int no_foo;", StartsWithNo));
91  EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
92
93  DeclarationMatcher Abc = namedDecl(matchesName("a.*b.*c"));
94  EXPECT_TRUE(matches("int abc;", Abc));
95  EXPECT_TRUE(matches("int aFOObBARc;", Abc));
96  EXPECT_TRUE(notMatches("int cab;", Abc));
97  EXPECT_TRUE(matches("int cabc;", Abc));
98
99  DeclarationMatcher StartsWithK = namedDecl(matchesName(":k[^:]*$"));
100  EXPECT_TRUE(matches("int k;", StartsWithK));
101  EXPECT_TRUE(matches("int kAbc;", StartsWithK));
102  EXPECT_TRUE(matches("namespace x { int kTest; }", StartsWithK));
103  EXPECT_TRUE(matches("class C { int k; };", StartsWithK));
104  EXPECT_TRUE(notMatches("class C { int ckc; };", StartsWithK));
105}
106
107TEST(DeclarationMatcher, MatchClass) {
108  DeclarationMatcher ClassMatcher(recordDecl());
109  llvm::Triple Triple(llvm::sys::getDefaultTargetTriple());
110  if (Triple.getOS() != llvm::Triple::Win32 ||
111      Triple.getEnvironment() != llvm::Triple::MSVC)
112    EXPECT_FALSE(matches("", ClassMatcher));
113  else
114    // Matches class type_info.
115    EXPECT_TRUE(matches("", ClassMatcher));
116
117  DeclarationMatcher ClassX = recordDecl(recordDecl(hasName("X")));
118  EXPECT_TRUE(matches("class X;", ClassX));
119  EXPECT_TRUE(matches("class X {};", ClassX));
120  EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
121  EXPECT_TRUE(notMatches("", ClassX));
122}
123
124TEST(DeclarationMatcher, ClassIsDerived) {
125  DeclarationMatcher IsDerivedFromX = recordDecl(isDerivedFrom("X"));
126
127  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
128  EXPECT_TRUE(notMatches("class X {};", IsDerivedFromX));
129  EXPECT_TRUE(notMatches("class X;", IsDerivedFromX));
130  EXPECT_TRUE(notMatches("class Y;", IsDerivedFromX));
131  EXPECT_TRUE(notMatches("", IsDerivedFromX));
132
133  DeclarationMatcher IsAX = recordDecl(isSameOrDerivedFrom("X"));
134
135  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsAX));
136  EXPECT_TRUE(matches("class X {};", IsAX));
137  EXPECT_TRUE(matches("class X;", IsAX));
138  EXPECT_TRUE(notMatches("class Y;", IsAX));
139  EXPECT_TRUE(notMatches("", IsAX));
140
141  DeclarationMatcher ZIsDerivedFromX =
142      recordDecl(hasName("Z"), isDerivedFrom("X"));
143  EXPECT_TRUE(
144      matches("class X {}; class Y : public X {}; class Z : public Y {};",
145              ZIsDerivedFromX));
146  EXPECT_TRUE(
147      matches("class X {};"
148              "template<class T> class Y : public X {};"
149              "class Z : public Y<int> {};", ZIsDerivedFromX));
150  EXPECT_TRUE(matches("class X {}; template<class T> class Z : public X {};",
151                      ZIsDerivedFromX));
152  EXPECT_TRUE(
153      matches("template<class T> class X {}; "
154              "template<class T> class Z : public X<T> {};",
155              ZIsDerivedFromX));
156  EXPECT_TRUE(
157      matches("template<class T, class U=T> class X {}; "
158              "template<class T> class Z : public X<T> {};",
159              ZIsDerivedFromX));
160  EXPECT_TRUE(
161      notMatches("template<class X> class A { class Z : public X {}; };",
162                 ZIsDerivedFromX));
163  EXPECT_TRUE(
164      matches("template<class X> class A { public: class Z : public X {}; }; "
165              "class X{}; void y() { A<X>::Z z; }", ZIsDerivedFromX));
166  EXPECT_TRUE(
167      matches("template <class T> class X {}; "
168              "template<class Y> class A { class Z : public X<Y> {}; };",
169              ZIsDerivedFromX));
170  EXPECT_TRUE(
171      notMatches("template<template<class T> class X> class A { "
172                 "  class Z : public X<int> {}; };", ZIsDerivedFromX));
173  EXPECT_TRUE(
174      matches("template<template<class T> class X> class A { "
175              "  public: class Z : public X<int> {}; }; "
176              "template<class T> class X {}; void y() { A<X>::Z z; }",
177              ZIsDerivedFromX));
178  EXPECT_TRUE(
179      notMatches("template<class X> class A { class Z : public X::D {}; };",
180                 ZIsDerivedFromX));
181  EXPECT_TRUE(
182      matches("template<class X> class A { public: "
183              "  class Z : public X::D {}; }; "
184              "class Y { public: class X {}; typedef X D; }; "
185              "void y() { A<Y>::Z z; }", ZIsDerivedFromX));
186  EXPECT_TRUE(
187      matches("class X {}; typedef X Y; class Z : public Y {};",
188              ZIsDerivedFromX));
189  EXPECT_TRUE(
190      matches("template<class T> class Y { typedef typename T::U X; "
191              "  class Z : public X {}; };", ZIsDerivedFromX));
192  EXPECT_TRUE(matches("class X {}; class Z : public ::X {};",
193                      ZIsDerivedFromX));
194  EXPECT_TRUE(
195      notMatches("template<class T> class X {}; "
196                "template<class T> class A { class Z : public X<T>::D {}; };",
197                ZIsDerivedFromX));
198  EXPECT_TRUE(
199      matches("template<class T> class X { public: typedef X<T> D; }; "
200              "template<class T> class A { public: "
201              "  class Z : public X<T>::D {}; }; void y() { A<int>::Z z; }",
202              ZIsDerivedFromX));
203  EXPECT_TRUE(
204      notMatches("template<class X> class A { class Z : public X::D::E {}; };",
205                 ZIsDerivedFromX));
206  EXPECT_TRUE(
207      matches("class X {}; typedef X V; typedef V W; class Z : public W {};",
208              ZIsDerivedFromX));
209  EXPECT_TRUE(
210      matches("class X {}; class Y : public X {}; "
211              "typedef Y V; typedef V W; class Z : public W {};",
212              ZIsDerivedFromX));
213  EXPECT_TRUE(
214      matches("template<class T, class U> class X {}; "
215              "template<class T> class A { class Z : public X<T, int> {}; };",
216              ZIsDerivedFromX));
217  EXPECT_TRUE(
218      notMatches("template<class X> class D { typedef X A; typedef A B; "
219                 "  typedef B C; class Z : public C {}; };",
220                 ZIsDerivedFromX));
221  EXPECT_TRUE(
222      matches("class X {}; typedef X A; typedef A B; "
223              "class Z : public B {};", ZIsDerivedFromX));
224  EXPECT_TRUE(
225      matches("class X {}; typedef X A; typedef A B; typedef B C; "
226              "class Z : public C {};", ZIsDerivedFromX));
227  EXPECT_TRUE(
228      matches("class U {}; typedef U X; typedef X V; "
229              "class Z : public V {};", ZIsDerivedFromX));
230  EXPECT_TRUE(
231      matches("class Base {}; typedef Base X; "
232              "class Z : public Base {};", ZIsDerivedFromX));
233  EXPECT_TRUE(
234      matches("class Base {}; typedef Base Base2; typedef Base2 X; "
235              "class Z : public Base {};", ZIsDerivedFromX));
236  EXPECT_TRUE(
237      notMatches("class Base {}; class Base2 {}; typedef Base2 X; "
238                 "class Z : public Base {};", ZIsDerivedFromX));
239  EXPECT_TRUE(
240      matches("class A {}; typedef A X; typedef A Y; "
241              "class Z : public Y {};", ZIsDerivedFromX));
242  EXPECT_TRUE(
243      notMatches("template <typename T> class Z;"
244                 "template <> class Z<void> {};"
245                 "template <typename T> class Z : public Z<void> {};",
246                 IsDerivedFromX));
247  EXPECT_TRUE(
248      matches("template <typename T> class X;"
249              "template <> class X<void> {};"
250              "template <typename T> class X : public X<void> {};",
251              IsDerivedFromX));
252  EXPECT_TRUE(matches(
253      "class X {};"
254      "template <typename T> class Z;"
255      "template <> class Z<void> {};"
256      "template <typename T> class Z : public Z<void>, public X {};",
257      ZIsDerivedFromX));
258  EXPECT_TRUE(
259      notMatches("template<int> struct X;"
260                 "template<int i> struct X : public X<i-1> {};",
261                 recordDecl(isDerivedFrom(recordDecl(hasName("Some"))))));
262  EXPECT_TRUE(matches(
263      "struct A {};"
264      "template<int> struct X;"
265      "template<int i> struct X : public X<i-1> {};"
266      "template<> struct X<0> : public A {};"
267      "struct B : public X<42> {};",
268      recordDecl(hasName("B"), isDerivedFrom(recordDecl(hasName("A"))))));
269
270  // FIXME: Once we have better matchers for template type matching,
271  // get rid of the Variable(...) matching and match the right template
272  // declarations directly.
273  const char *RecursiveTemplateOneParameter =
274      "class Base1 {}; class Base2 {};"
275      "template <typename T> class Z;"
276      "template <> class Z<void> : public Base1 {};"
277      "template <> class Z<int> : public Base2 {};"
278      "template <> class Z<float> : public Z<void> {};"
279      "template <> class Z<double> : public Z<int> {};"
280      "template <typename T> class Z : public Z<float>, public Z<double> {};"
281      "void f() { Z<float> z_float; Z<double> z_double; Z<char> z_char; }";
282  EXPECT_TRUE(matches(
283      RecursiveTemplateOneParameter,
284      varDecl(hasName("z_float"),
285              hasInitializer(hasType(recordDecl(isDerivedFrom("Base1")))))));
286  EXPECT_TRUE(notMatches(
287      RecursiveTemplateOneParameter,
288      varDecl(hasName("z_float"),
289              hasInitializer(hasType(recordDecl(isDerivedFrom("Base2")))))));
290  EXPECT_TRUE(matches(
291      RecursiveTemplateOneParameter,
292      varDecl(hasName("z_char"),
293              hasInitializer(hasType(recordDecl(isDerivedFrom("Base1"),
294                                                isDerivedFrom("Base2")))))));
295
296  const char *RecursiveTemplateTwoParameters =
297      "class Base1 {}; class Base2 {};"
298      "template <typename T1, typename T2> class Z;"
299      "template <typename T> class Z<void, T> : public Base1 {};"
300      "template <typename T> class Z<int, T> : public Base2 {};"
301      "template <typename T> class Z<float, T> : public Z<void, T> {};"
302      "template <typename T> class Z<double, T> : public Z<int, T> {};"
303      "template <typename T1, typename T2> class Z : "
304      "    public Z<float, T2>, public Z<double, T2> {};"
305      "void f() { Z<float, void> z_float; Z<double, void> z_double; "
306      "           Z<char, void> z_char; }";
307  EXPECT_TRUE(matches(
308      RecursiveTemplateTwoParameters,
309      varDecl(hasName("z_float"),
310              hasInitializer(hasType(recordDecl(isDerivedFrom("Base1")))))));
311  EXPECT_TRUE(notMatches(
312      RecursiveTemplateTwoParameters,
313      varDecl(hasName("z_float"),
314              hasInitializer(hasType(recordDecl(isDerivedFrom("Base2")))))));
315  EXPECT_TRUE(matches(
316      RecursiveTemplateTwoParameters,
317      varDecl(hasName("z_char"),
318              hasInitializer(hasType(recordDecl(isDerivedFrom("Base1"),
319                                                isDerivedFrom("Base2")))))));
320  EXPECT_TRUE(matches(
321      "namespace ns { class X {}; class Y : public X {}; }",
322      recordDecl(isDerivedFrom("::ns::X"))));
323  EXPECT_TRUE(notMatches(
324      "class X {}; class Y : public X {};",
325      recordDecl(isDerivedFrom("::ns::X"))));
326
327  EXPECT_TRUE(matches(
328      "class X {}; class Y : public X {};",
329      recordDecl(isDerivedFrom(recordDecl(hasName("X")).bind("test")))));
330
331  EXPECT_TRUE(matches(
332      "template<typename T> class X {};"
333      "template<typename T> using Z = X<T>;"
334      "template <typename T> class Y : Z<T> {};",
335      recordDecl(isDerivedFrom(namedDecl(hasName("X"))))));
336}
337
338TEST(DeclarationMatcher, hasMethod) {
339  EXPECT_TRUE(matches("class A { void func(); };",
340                      recordDecl(hasMethod(hasName("func")))));
341  EXPECT_TRUE(notMatches("class A { void func(); };",
342                         recordDecl(hasMethod(isPublic()))));
343}
344
345TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
346  EXPECT_TRUE(matches(
347     "template <typename T> struct A {"
348     "  template <typename T2> struct F {};"
349     "};"
350     "template <typename T> struct B : A<T>::template F<T> {};"
351     "B<int> b;",
352     recordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
353}
354
355TEST(DeclarationMatcher, hasDeclContext) {
356  EXPECT_TRUE(matches(
357      "namespace N {"
358      "  namespace M {"
359      "    class D {};"
360      "  }"
361      "}",
362      recordDecl(hasDeclContext(namespaceDecl(hasName("M"))))));
363  EXPECT_TRUE(notMatches(
364      "namespace N {"
365      "  namespace M {"
366      "    class D {};"
367      "  }"
368      "}",
369      recordDecl(hasDeclContext(namespaceDecl(hasName("N"))))));
370
371  EXPECT_TRUE(matches("namespace {"
372                      "  namespace M {"
373                      "    class D {};"
374                      "  }"
375                      "}",
376                      recordDecl(hasDeclContext(namespaceDecl(
377                          hasName("M"), hasDeclContext(namespaceDecl()))))));
378}
379
380TEST(ClassTemplate, DoesNotMatchClass) {
381  DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
382  EXPECT_TRUE(notMatches("class X;", ClassX));
383  EXPECT_TRUE(notMatches("class X {};", ClassX));
384}
385
386TEST(ClassTemplate, MatchesClassTemplate) {
387  DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
388  EXPECT_TRUE(matches("template<typename T> class X {};", ClassX));
389  EXPECT_TRUE(matches("class Z { template<class T> class X {}; };", ClassX));
390}
391
392TEST(ClassTemplate, DoesNotMatchClassTemplateExplicitSpecialization) {
393  EXPECT_TRUE(notMatches("template<typename T> class X { };"
394                         "template<> class X<int> { int a; };",
395              classTemplateDecl(hasName("X"),
396                                hasDescendant(fieldDecl(hasName("a"))))));
397}
398
399TEST(ClassTemplate, DoesNotMatchClassTemplatePartialSpecialization) {
400  EXPECT_TRUE(notMatches("template<typename T, typename U> class X { };"
401                         "template<typename T> class X<T, int> { int a; };",
402              classTemplateDecl(hasName("X"),
403                                hasDescendant(fieldDecl(hasName("a"))))));
404}
405
406TEST(AllOf, AllOverloadsWork) {
407  const char Program[] =
408      "struct T { };"
409      "int f(int, T*, int, int);"
410      "void g(int x) { T t; f(x, &t, 3, 4); }";
411  EXPECT_TRUE(matches(Program,
412      callExpr(allOf(callee(functionDecl(hasName("f"))),
413                     hasArgument(0, declRefExpr(to(varDecl())))))));
414  EXPECT_TRUE(matches(Program,
415      callExpr(allOf(callee(functionDecl(hasName("f"))),
416                     hasArgument(0, declRefExpr(to(varDecl()))),
417                     hasArgument(1, hasType(pointsTo(
418                                        recordDecl(hasName("T")))))))));
419  EXPECT_TRUE(matches(Program,
420      callExpr(allOf(callee(functionDecl(hasName("f"))),
421                     hasArgument(0, declRefExpr(to(varDecl()))),
422                     hasArgument(1, hasType(pointsTo(
423                                        recordDecl(hasName("T"))))),
424                     hasArgument(2, integerLiteral(equals(3)))))));
425  EXPECT_TRUE(matches(Program,
426      callExpr(allOf(callee(functionDecl(hasName("f"))),
427                     hasArgument(0, declRefExpr(to(varDecl()))),
428                     hasArgument(1, hasType(pointsTo(
429                                        recordDecl(hasName("T"))))),
430                     hasArgument(2, integerLiteral(equals(3))),
431                     hasArgument(3, integerLiteral(equals(4)))))));
432}
433
434TEST(DeclarationMatcher, MatchAnyOf) {
435  DeclarationMatcher YOrZDerivedFromX =
436      recordDecl(anyOf(hasName("Y"), allOf(isDerivedFrom("X"), hasName("Z"))));
437  EXPECT_TRUE(
438      matches("class X {}; class Z : public X {};", YOrZDerivedFromX));
439  EXPECT_TRUE(matches("class Y {};", YOrZDerivedFromX));
440  EXPECT_TRUE(
441      notMatches("class X {}; class W : public X {};", YOrZDerivedFromX));
442  EXPECT_TRUE(notMatches("class Z {};", YOrZDerivedFromX));
443
444  DeclarationMatcher XOrYOrZOrU =
445      recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U")));
446  EXPECT_TRUE(matches("class X {};", XOrYOrZOrU));
447  EXPECT_TRUE(notMatches("class V {};", XOrYOrZOrU));
448
449  DeclarationMatcher XOrYOrZOrUOrV =
450      recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U"),
451                       hasName("V")));
452  EXPECT_TRUE(matches("class X {};", XOrYOrZOrUOrV));
453  EXPECT_TRUE(matches("class Y {};", XOrYOrZOrUOrV));
454  EXPECT_TRUE(matches("class Z {};", XOrYOrZOrUOrV));
455  EXPECT_TRUE(matches("class U {};", XOrYOrZOrUOrV));
456  EXPECT_TRUE(matches("class V {};", XOrYOrZOrUOrV));
457  EXPECT_TRUE(notMatches("class A {};", XOrYOrZOrUOrV));
458}
459
460TEST(DeclarationMatcher, MatchHas) {
461  DeclarationMatcher HasClassX = recordDecl(has(recordDecl(hasName("X"))));
462  EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
463  EXPECT_TRUE(matches("class X {};", HasClassX));
464
465  DeclarationMatcher YHasClassX =
466      recordDecl(hasName("Y"), has(recordDecl(hasName("X"))));
467  EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
468  EXPECT_TRUE(notMatches("class X {};", YHasClassX));
469  EXPECT_TRUE(
470      notMatches("class Y { class Z { class X {}; }; };", YHasClassX));
471}
472
473TEST(DeclarationMatcher, MatchHasRecursiveAllOf) {
474  DeclarationMatcher Recursive =
475    recordDecl(
476      has(recordDecl(
477        has(recordDecl(hasName("X"))),
478        has(recordDecl(hasName("Y"))),
479        hasName("Z"))),
480      has(recordDecl(
481        has(recordDecl(hasName("A"))),
482        has(recordDecl(hasName("B"))),
483        hasName("C"))),
484      hasName("F"));
485
486  EXPECT_TRUE(matches(
487      "class F {"
488      "  class Z {"
489      "    class X {};"
490      "    class Y {};"
491      "  };"
492      "  class C {"
493      "    class A {};"
494      "    class B {};"
495      "  };"
496      "};", Recursive));
497
498  EXPECT_TRUE(matches(
499      "class F {"
500      "  class Z {"
501      "    class A {};"
502      "    class X {};"
503      "    class Y {};"
504      "  };"
505      "  class C {"
506      "    class X {};"
507      "    class A {};"
508      "    class B {};"
509      "  };"
510      "};", Recursive));
511
512  EXPECT_TRUE(matches(
513      "class O1 {"
514      "  class O2 {"
515      "    class F {"
516      "      class Z {"
517      "        class A {};"
518      "        class X {};"
519      "        class Y {};"
520      "      };"
521      "      class C {"
522      "        class X {};"
523      "        class A {};"
524      "        class B {};"
525      "      };"
526      "    };"
527      "  };"
528      "};", Recursive));
529}
530
531TEST(DeclarationMatcher, MatchHasRecursiveAnyOf) {
532  DeclarationMatcher Recursive =
533      recordDecl(
534          anyOf(
535              has(recordDecl(
536                  anyOf(
537                      has(recordDecl(
538                          hasName("X"))),
539                      has(recordDecl(
540                          hasName("Y"))),
541                      hasName("Z")))),
542              has(recordDecl(
543                  anyOf(
544                      hasName("C"),
545                      has(recordDecl(
546                          hasName("A"))),
547                      has(recordDecl(
548                          hasName("B")))))),
549              hasName("F")));
550
551  EXPECT_TRUE(matches("class F {};", Recursive));
552  EXPECT_TRUE(matches("class Z {};", Recursive));
553  EXPECT_TRUE(matches("class C {};", Recursive));
554  EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
555  EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
556  EXPECT_TRUE(
557      matches("class O1 { class O2 {"
558              "  class M { class N { class B {}; }; }; "
559              "}; };", Recursive));
560}
561
562TEST(DeclarationMatcher, MatchNot) {
563  DeclarationMatcher NotClassX =
564      recordDecl(
565          isDerivedFrom("Y"),
566          unless(hasName("X")));
567  EXPECT_TRUE(notMatches("", NotClassX));
568  EXPECT_TRUE(notMatches("class Y {};", NotClassX));
569  EXPECT_TRUE(matches("class Y {}; class Z : public Y {};", NotClassX));
570  EXPECT_TRUE(notMatches("class Y {}; class X : public Y {};", NotClassX));
571  EXPECT_TRUE(
572      notMatches("class Y {}; class Z {}; class X : public Y {};",
573                 NotClassX));
574
575  DeclarationMatcher ClassXHasNotClassY =
576      recordDecl(
577          hasName("X"),
578          has(recordDecl(hasName("Z"))),
579          unless(
580              has(recordDecl(hasName("Y")))));
581  EXPECT_TRUE(matches("class X { class Z {}; };", ClassXHasNotClassY));
582  EXPECT_TRUE(notMatches("class X { class Y {}; class Z {}; };",
583                         ClassXHasNotClassY));
584}
585
586TEST(DeclarationMatcher, HasDescendant) {
587  DeclarationMatcher ZDescendantClassX =
588      recordDecl(
589          hasDescendant(recordDecl(hasName("X"))),
590          hasName("Z"));
591  EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
592  EXPECT_TRUE(
593      matches("class Z { class Y { class X {}; }; };", ZDescendantClassX));
594  EXPECT_TRUE(
595      matches("class Z { class A { class Y { class X {}; }; }; };",
596              ZDescendantClassX));
597  EXPECT_TRUE(
598      matches("class Z { class A { class B { class Y { class X {}; }; }; }; };",
599              ZDescendantClassX));
600  EXPECT_TRUE(notMatches("class Z {};", ZDescendantClassX));
601
602  DeclarationMatcher ZDescendantClassXHasClassY =
603      recordDecl(
604          hasDescendant(recordDecl(has(recordDecl(hasName("Y"))),
605                              hasName("X"))),
606          hasName("Z"));
607  EXPECT_TRUE(matches("class Z { class X { class Y {}; }; };",
608              ZDescendantClassXHasClassY));
609  EXPECT_TRUE(
610      matches("class Z { class A { class B { class X { class Y {}; }; }; }; };",
611              ZDescendantClassXHasClassY));
612  EXPECT_TRUE(notMatches(
613      "class Z {"
614      "  class A {"
615      "    class B {"
616      "      class X {"
617      "        class C {"
618      "          class Y {};"
619      "        };"
620      "      };"
621      "    }; "
622      "  };"
623      "};", ZDescendantClassXHasClassY));
624
625  DeclarationMatcher ZDescendantClassXDescendantClassY =
626      recordDecl(
627          hasDescendant(recordDecl(hasDescendant(recordDecl(hasName("Y"))),
628                                   hasName("X"))),
629          hasName("Z"));
630  EXPECT_TRUE(
631      matches("class Z { class A { class X { class B { class Y {}; }; }; }; };",
632              ZDescendantClassXDescendantClassY));
633  EXPECT_TRUE(matches(
634      "class Z {"
635      "  class A {"
636      "    class X {"
637      "      class B {"
638      "        class Y {};"
639      "      };"
640      "      class Y {};"
641      "    };"
642      "  };"
643      "};", ZDescendantClassXDescendantClassY));
644}
645
646// Implements a run method that returns whether BoundNodes contains a
647// Decl bound to Id that can be dynamically cast to T.
648// Optionally checks that the check succeeded a specific number of times.
649template <typename T>
650class VerifyIdIsBoundTo : public BoundNodesCallback {
651public:
652  // Create an object that checks that a node of type \c T was bound to \c Id.
653  // Does not check for a certain number of matches.
654  explicit VerifyIdIsBoundTo(llvm::StringRef Id)
655    : Id(Id), ExpectedCount(-1), Count(0) {}
656
657  // Create an object that checks that a node of type \c T was bound to \c Id.
658  // Checks that there were exactly \c ExpectedCount matches.
659  VerifyIdIsBoundTo(llvm::StringRef Id, int ExpectedCount)
660    : Id(Id), ExpectedCount(ExpectedCount), Count(0) {}
661
662  // Create an object that checks that a node of type \c T was bound to \c Id.
663  // Checks that there was exactly one match with the name \c ExpectedName.
664  // Note that \c T must be a NamedDecl for this to work.
665  VerifyIdIsBoundTo(llvm::StringRef Id, llvm::StringRef ExpectedName,
666                    int ExpectedCount = 1)
667      : Id(Id), ExpectedCount(ExpectedCount), Count(0),
668        ExpectedName(ExpectedName) {}
669
670  void onEndOfTranslationUnit() override {
671    if (ExpectedCount != -1)
672      EXPECT_EQ(ExpectedCount, Count);
673    if (!ExpectedName.empty())
674      EXPECT_EQ(ExpectedName, Name);
675    Count = 0;
676    Name.clear();
677  }
678
679  ~VerifyIdIsBoundTo() {
680    EXPECT_EQ(0, Count);
681    EXPECT_EQ("", Name);
682  }
683
684  virtual bool run(const BoundNodes *Nodes) {
685    const BoundNodes::IDToNodeMap &M = Nodes->getMap();
686    if (Nodes->getNodeAs<T>(Id)) {
687      ++Count;
688      if (const NamedDecl *Named = Nodes->getNodeAs<NamedDecl>(Id)) {
689        Name = Named->getNameAsString();
690      } else if (const NestedNameSpecifier *NNS =
691                 Nodes->getNodeAs<NestedNameSpecifier>(Id)) {
692        llvm::raw_string_ostream OS(Name);
693        NNS->print(OS, PrintingPolicy(LangOptions()));
694      }
695      BoundNodes::IDToNodeMap::const_iterator I = M.find(Id);
696      EXPECT_NE(M.end(), I);
697      if (I != M.end())
698        EXPECT_EQ(Nodes->getNodeAs<T>(Id), I->second.get<T>());
699      return true;
700    }
701    EXPECT_TRUE(M.count(Id) == 0 ||
702                M.find(Id)->second.template get<T>() == nullptr);
703    return false;
704  }
705
706  virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
707    return run(Nodes);
708  }
709
710private:
711  const std::string Id;
712  const int ExpectedCount;
713  int Count;
714  const std::string ExpectedName;
715  std::string Name;
716};
717
718TEST(HasDescendant, MatchesDescendantTypes) {
719  EXPECT_TRUE(matches("void f() { int i = 3; }",
720                      decl(hasDescendant(loc(builtinType())))));
721  EXPECT_TRUE(matches("void f() { int i = 3; }",
722                      stmt(hasDescendant(builtinType()))));
723
724  EXPECT_TRUE(matches("void f() { int i = 3; }",
725                      stmt(hasDescendant(loc(builtinType())))));
726  EXPECT_TRUE(matches("void f() { int i = 3; }",
727                      stmt(hasDescendant(qualType(builtinType())))));
728
729  EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
730                         stmt(hasDescendant(isInteger()))));
731
732  EXPECT_TRUE(matchAndVerifyResultTrue(
733      "void f() { int a; float c; int d; int e; }",
734      functionDecl(forEachDescendant(
735          varDecl(hasDescendant(isInteger())).bind("x"))),
736      new VerifyIdIsBoundTo<Decl>("x", 3)));
737}
738
739TEST(HasDescendant, MatchesDescendantsOfTypes) {
740  EXPECT_TRUE(matches("void f() { int*** i; }",
741                      qualType(hasDescendant(builtinType()))));
742  EXPECT_TRUE(matches("void f() { int*** i; }",
743                      qualType(hasDescendant(
744                          pointerType(pointee(builtinType()))))));
745  EXPECT_TRUE(matches("void f() { int*** i; }",
746                      typeLoc(hasDescendant(loc(builtinType())))));
747
748  EXPECT_TRUE(matchAndVerifyResultTrue(
749      "void f() { int*** i; }",
750      qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
751      new VerifyIdIsBoundTo<Type>("x", 2)));
752}
753
754TEST(Has, MatchesChildrenOfTypes) {
755  EXPECT_TRUE(matches("int i;",
756                      varDecl(hasName("i"), has(isInteger()))));
757  EXPECT_TRUE(notMatches("int** i;",
758                         varDecl(hasName("i"), has(isInteger()))));
759  EXPECT_TRUE(matchAndVerifyResultTrue(
760      "int (*f)(float, int);",
761      qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
762      new VerifyIdIsBoundTo<QualType>("x", 2)));
763}
764
765TEST(Has, MatchesChildTypes) {
766  EXPECT_TRUE(matches(
767      "int* i;",
768      varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
769  EXPECT_TRUE(notMatches(
770      "int* i;",
771      varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
772}
773
774TEST(Enum, DoesNotMatchClasses) {
775  EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
776}
777
778TEST(Enum, MatchesEnums) {
779  EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
780}
781
782TEST(EnumConstant, Matches) {
783  DeclarationMatcher Matcher = enumConstantDecl(hasName("A"));
784  EXPECT_TRUE(matches("enum X{ A };", Matcher));
785  EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
786  EXPECT_TRUE(notMatches("enum X {};", Matcher));
787}
788
789TEST(StatementMatcher, Has) {
790  StatementMatcher HasVariableI =
791      expr(hasType(pointsTo(recordDecl(hasName("X")))),
792           has(declRefExpr(to(varDecl(hasName("i"))))));
793
794  EXPECT_TRUE(matches(
795      "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
796  EXPECT_TRUE(notMatches(
797      "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
798}
799
800TEST(StatementMatcher, HasDescendant) {
801  StatementMatcher HasDescendantVariableI =
802      expr(hasType(pointsTo(recordDecl(hasName("X")))),
803           hasDescendant(declRefExpr(to(varDecl(hasName("i"))))));
804
805  EXPECT_TRUE(matches(
806      "class X; X *x(bool); bool b(int); void c() { int i; x(b(i)); }",
807      HasDescendantVariableI));
808  EXPECT_TRUE(notMatches(
809      "class X; X *x(bool); bool b(int); void c() { int i; x(b(42)); }",
810      HasDescendantVariableI));
811}
812
813TEST(TypeMatcher, MatchesClassType) {
814  TypeMatcher TypeA = hasDeclaration(recordDecl(hasName("A")));
815
816  EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
817  EXPECT_TRUE(notMatches("class A {};", TypeA));
818
819  TypeMatcher TypeDerivedFromA = hasDeclaration(recordDecl(isDerivedFrom("A")));
820
821  EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
822              TypeDerivedFromA));
823  EXPECT_TRUE(notMatches("class A {};", TypeA));
824
825  TypeMatcher TypeAHasClassB = hasDeclaration(
826      recordDecl(hasName("A"), has(recordDecl(hasName("B")))));
827
828  EXPECT_TRUE(
829      matches("class A { public: A *a; class B {}; };", TypeAHasClassB));
830}
831
832TEST(Matcher, BindMatchedNodes) {
833  DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));
834
835  EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
836      ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("x")));
837
838  EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
839      ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("other-id")));
840
841  TypeMatcher TypeAHasClassB = hasDeclaration(
842      recordDecl(hasName("A"), has(recordDecl(hasName("B")).bind("b"))));
843
844  EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
845      TypeAHasClassB,
846      new VerifyIdIsBoundTo<Decl>("b")));
847
848  StatementMatcher MethodX =
849      callExpr(callee(methodDecl(hasName("x")))).bind("x");
850
851  EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
852      MethodX,
853      new VerifyIdIsBoundTo<CXXMemberCallExpr>("x")));
854}
855
856TEST(Matcher, BindTheSameNameInAlternatives) {
857  StatementMatcher matcher = anyOf(
858      binaryOperator(hasOperatorName("+"),
859                     hasLHS(expr().bind("x")),
860                     hasRHS(integerLiteral(equals(0)))),
861      binaryOperator(hasOperatorName("+"),
862                     hasLHS(integerLiteral(equals(0))),
863                     hasRHS(expr().bind("x"))));
864
865  EXPECT_TRUE(matchAndVerifyResultTrue(
866      // The first branch of the matcher binds x to 0 but then fails.
867      // The second branch binds x to f() and succeeds.
868      "int f() { return 0 + f(); }",
869      matcher,
870      new VerifyIdIsBoundTo<CallExpr>("x")));
871}
872
873TEST(Matcher, BindsIDForMemoizedResults) {
874  // Using the same matcher in two match expressions will make memoization
875  // kick in.
876  DeclarationMatcher ClassX = recordDecl(hasName("X")).bind("x");
877  EXPECT_TRUE(matchAndVerifyResultTrue(
878      "class A { class B { class X {}; }; };",
879      DeclarationMatcher(anyOf(
880          recordDecl(hasName("A"), hasDescendant(ClassX)),
881          recordDecl(hasName("B"), hasDescendant(ClassX)))),
882      new VerifyIdIsBoundTo<Decl>("x", 2)));
883}
884
885TEST(HasDeclaration, HasDeclarationOfEnumType) {
886  EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
887                      expr(hasType(pointsTo(
888                          qualType(hasDeclaration(enumDecl(hasName("X")))))))));
889}
890
891TEST(HasDeclaration, HasGetDeclTraitTest) {
892  EXPECT_TRUE(internal::has_getDecl<TypedefType>::value);
893  EXPECT_TRUE(internal::has_getDecl<RecordType>::value);
894  EXPECT_FALSE(internal::has_getDecl<TemplateSpecializationType>::value);
895}
896
897TEST(HasDeclaration, HasDeclarationOfTypeWithDecl) {
898  EXPECT_TRUE(matches("typedef int X; X a;",
899                      varDecl(hasName("a"),
900                              hasType(typedefType(hasDeclaration(decl()))))));
901
902  // FIXME: Add tests for other types with getDecl() (e.g. RecordType)
903}
904
905TEST(HasDeclaration, HasDeclarationOfTemplateSpecializationType) {
906  EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
907                      varDecl(hasType(templateSpecializationType(
908                          hasDeclaration(namedDecl(hasName("A"))))))));
909}
910
911TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
912  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
913  EXPECT_TRUE(
914      matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
915  EXPECT_TRUE(
916      notMatches("class X {}; void y(X *x) { x; }",
917                 expr(hasType(ClassX))));
918  EXPECT_TRUE(
919      matches("class X {}; void y(X *x) { x; }",
920              expr(hasType(pointsTo(ClassX)))));
921}
922
923TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
924  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
925  EXPECT_TRUE(
926      matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
927  EXPECT_TRUE(
928      notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
929  EXPECT_TRUE(
930      matches("class X {}; void y() { X *x; }",
931              varDecl(hasType(pointsTo(ClassX)))));
932}
933
934TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
935  DeclarationMatcher ClassX = recordDecl(hasName("X"));
936  EXPECT_TRUE(
937      matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
938  EXPECT_TRUE(
939      notMatches("class X {}; void y(X *x) { x; }",
940                 expr(hasType(ClassX))));
941}
942
943TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
944  DeclarationMatcher ClassX = recordDecl(hasName("X"));
945  EXPECT_TRUE(
946      matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
947  EXPECT_TRUE(
948      notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
949}
950
951TEST(HasTypeLoc, MatchesDeclaratorDecls) {
952  EXPECT_TRUE(matches("int x;",
953                      varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
954
955  // Make sure we don't crash on implicit constructors.
956  EXPECT_TRUE(notMatches("class X {}; X x;",
957                         declaratorDecl(hasTypeLoc(loc(asString("int"))))));
958}
959
960TEST(Matcher, Call) {
961  // FIXME: Do we want to overload Call() to directly take
962  // Matcher<Decl>, too?
963  StatementMatcher MethodX = callExpr(hasDeclaration(methodDecl(hasName("x"))));
964
965  EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
966  EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
967
968  StatementMatcher MethodOnY =
969      memberCallExpr(on(hasType(recordDecl(hasName("Y")))));
970
971  EXPECT_TRUE(
972      matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
973              MethodOnY));
974  EXPECT_TRUE(
975      matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
976              MethodOnY));
977  EXPECT_TRUE(
978      notMatches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
979                 MethodOnY));
980  EXPECT_TRUE(
981      notMatches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
982                 MethodOnY));
983  EXPECT_TRUE(
984      notMatches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
985                 MethodOnY));
986
987  StatementMatcher MethodOnYPointer =
988      memberCallExpr(on(hasType(pointsTo(recordDecl(hasName("Y"))))));
989
990  EXPECT_TRUE(
991      matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
992              MethodOnYPointer));
993  EXPECT_TRUE(
994      matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
995              MethodOnYPointer));
996  EXPECT_TRUE(
997      matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
998              MethodOnYPointer));
999  EXPECT_TRUE(
1000      notMatches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
1001                 MethodOnYPointer));
1002  EXPECT_TRUE(
1003      notMatches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
1004                 MethodOnYPointer));
1005}
1006
1007TEST(Matcher, Lambda) {
1008  EXPECT_TRUE(matches("auto f = [] (int i) { return i; };",
1009                      lambdaExpr()));
1010}
1011
1012TEST(Matcher, ForRange) {
1013  EXPECT_TRUE(matches("int as[] = { 1, 2, 3 };"
1014                      "void f() { for (auto &a : as); }",
1015                      forRangeStmt()));
1016  EXPECT_TRUE(notMatches("void f() { for (int i; i<5; ++i); }",
1017                         forRangeStmt()));
1018}
1019
1020TEST(Matcher, SubstNonTypeTemplateParm) {
1021  EXPECT_FALSE(matches("template<int N>\n"
1022                       "struct A {  static const int n = 0; };\n"
1023                       "struct B : public A<42> {};",
1024                       substNonTypeTemplateParmExpr()));
1025  EXPECT_TRUE(matches("template<int N>\n"
1026                      "struct A {  static const int n = N; };\n"
1027                      "struct B : public A<42> {};",
1028                      substNonTypeTemplateParmExpr()));
1029}
1030
1031TEST(Matcher, UserDefinedLiteral) {
1032  EXPECT_TRUE(matches("constexpr char operator \"\" _inc (const char i) {"
1033                      "  return i + 1;"
1034                      "}"
1035                      "char c = 'a'_inc;",
1036                      userDefinedLiteral()));
1037}
1038
1039TEST(Matcher, FlowControl) {
1040  EXPECT_TRUE(matches("void f() { while(true) { break; } }", breakStmt()));
1041  EXPECT_TRUE(matches("void f() { while(true) { continue; } }",
1042                      continueStmt()));
1043  EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", gotoStmt()));
1044  EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", labelStmt()));
1045  EXPECT_TRUE(matches("void f() { return; }", returnStmt()));
1046}
1047
1048TEST(HasType, MatchesAsString) {
1049  EXPECT_TRUE(
1050      matches("class Y { public: void x(); }; void z() {Y* y; y->x(); }",
1051              memberCallExpr(on(hasType(asString("class Y *"))))));
1052  EXPECT_TRUE(matches("class X { void x(int x) {} };",
1053      methodDecl(hasParameter(0, hasType(asString("int"))))));
1054  EXPECT_TRUE(matches("namespace ns { struct A {}; }  struct B { ns::A a; };",
1055      fieldDecl(hasType(asString("ns::A")))));
1056  EXPECT_TRUE(matches("namespace { struct A {}; }  struct B { A a; };",
1057      fieldDecl(hasType(asString("struct (anonymous namespace)::A")))));
1058}
1059
1060TEST(Matcher, OverloadedOperatorCall) {
1061  StatementMatcher OpCall = operatorCallExpr();
1062  // Unary operator
1063  EXPECT_TRUE(matches("class Y { }; "
1064              "bool operator!(Y x) { return false; }; "
1065              "Y y; bool c = !y;", OpCall));
1066  // No match -- special operators like "new", "delete"
1067  // FIXME: operator new takes size_t, for which we need stddef.h, for which
1068  // we need to figure out include paths in the test.
1069  // EXPECT_TRUE(NotMatches("#include <stddef.h>\n"
1070  //             "class Y { }; "
1071  //             "void *operator new(size_t size) { return 0; } "
1072  //             "Y *y = new Y;", OpCall));
1073  EXPECT_TRUE(notMatches("class Y { }; "
1074              "void operator delete(void *p) { } "
1075              "void a() {Y *y = new Y; delete y;}", OpCall));
1076  // Binary operator
1077  EXPECT_TRUE(matches("class Y { }; "
1078              "bool operator&&(Y x, Y y) { return true; }; "
1079              "Y a; Y b; bool c = a && b;",
1080              OpCall));
1081  // No match -- normal operator, not an overloaded one.
1082  EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
1083  EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
1084}
1085
1086TEST(Matcher, HasOperatorNameForOverloadedOperatorCall) {
1087  StatementMatcher OpCallAndAnd =
1088      operatorCallExpr(hasOverloadedOperatorName("&&"));
1089  EXPECT_TRUE(matches("class Y { }; "
1090              "bool operator&&(Y x, Y y) { return true; }; "
1091              "Y a; Y b; bool c = a && b;", OpCallAndAnd));
1092  StatementMatcher OpCallLessLess =
1093      operatorCallExpr(hasOverloadedOperatorName("<<"));
1094  EXPECT_TRUE(notMatches("class Y { }; "
1095              "bool operator&&(Y x, Y y) { return true; }; "
1096              "Y a; Y b; bool c = a && b;",
1097              OpCallLessLess));
1098  DeclarationMatcher ClassWithOpStar =
1099    recordDecl(hasMethod(hasOverloadedOperatorName("*")));
1100  EXPECT_TRUE(matches("class Y { int operator*(); };",
1101                      ClassWithOpStar));
1102  EXPECT_TRUE(notMatches("class Y { void myOperator(); };",
1103              ClassWithOpStar)) ;
1104}
1105
1106TEST(Matcher, NestedOverloadedOperatorCalls) {
1107  EXPECT_TRUE(matchAndVerifyResultTrue(
1108        "class Y { }; "
1109        "Y& operator&&(Y& x, Y& y) { return x; }; "
1110        "Y a; Y b; Y c; Y d = a && b && c;",
1111        operatorCallExpr(hasOverloadedOperatorName("&&")).bind("x"),
1112        new VerifyIdIsBoundTo<CXXOperatorCallExpr>("x", 2)));
1113  EXPECT_TRUE(matches(
1114        "class Y { }; "
1115        "Y& operator&&(Y& x, Y& y) { return x; }; "
1116        "Y a; Y b; Y c; Y d = a && b && c;",
1117        operatorCallExpr(hasParent(operatorCallExpr()))));
1118  EXPECT_TRUE(matches(
1119        "class Y { }; "
1120        "Y& operator&&(Y& x, Y& y) { return x; }; "
1121        "Y a; Y b; Y c; Y d = a && b && c;",
1122        operatorCallExpr(hasDescendant(operatorCallExpr()))));
1123}
1124
1125TEST(Matcher, ThisPointerType) {
1126  StatementMatcher MethodOnY =
1127    memberCallExpr(thisPointerType(recordDecl(hasName("Y"))));
1128
1129  EXPECT_TRUE(
1130      matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
1131              MethodOnY));
1132  EXPECT_TRUE(
1133      matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
1134              MethodOnY));
1135  EXPECT_TRUE(
1136      matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
1137              MethodOnY));
1138  EXPECT_TRUE(
1139      matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
1140              MethodOnY));
1141  EXPECT_TRUE(
1142      matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
1143              MethodOnY));
1144
1145  EXPECT_TRUE(matches(
1146      "class Y {"
1147      "  public: virtual void x();"
1148      "};"
1149      "class X : public Y {"
1150      "  public: virtual void x();"
1151      "};"
1152      "void z() { X *x; x->Y::x(); }", MethodOnY));
1153}
1154
1155TEST(Matcher, VariableUsage) {
1156  StatementMatcher Reference =
1157      declRefExpr(to(
1158          varDecl(hasInitializer(
1159              memberCallExpr(thisPointerType(recordDecl(hasName("Y"))))))));
1160
1161  EXPECT_TRUE(matches(
1162      "class Y {"
1163      " public:"
1164      "  bool x() const;"
1165      "};"
1166      "void z(const Y &y) {"
1167      "  bool b = y.x();"
1168      "  if (b) {}"
1169      "}", Reference));
1170
1171  EXPECT_TRUE(notMatches(
1172      "class Y {"
1173      " public:"
1174      "  bool x() const;"
1175      "};"
1176      "void z(const Y &y) {"
1177      "  bool b = y.x();"
1178      "}", Reference));
1179}
1180
1181TEST(Matcher, VarDecl_Storage) {
1182  auto M = varDecl(hasName("X"), hasLocalStorage());
1183  EXPECT_TRUE(matches("void f() { int X; }", M));
1184  EXPECT_TRUE(notMatches("int X;", M));
1185  EXPECT_TRUE(notMatches("void f() { static int X; }", M));
1186
1187  M = varDecl(hasName("X"), hasGlobalStorage());
1188  EXPECT_TRUE(notMatches("void f() { int X; }", M));
1189  EXPECT_TRUE(matches("int X;", M));
1190  EXPECT_TRUE(matches("void f() { static int X; }", M));
1191}
1192
1193TEST(Matcher, FindsVarDeclInFunctionParameter) {
1194  EXPECT_TRUE(matches(
1195      "void f(int i) {}",
1196      varDecl(hasName("i"))));
1197}
1198
1199TEST(Matcher, CalledVariable) {
1200  StatementMatcher CallOnVariableY =
1201      memberCallExpr(on(declRefExpr(to(varDecl(hasName("y"))))));
1202
1203  EXPECT_TRUE(matches(
1204      "class Y { public: void x() { Y y; y.x(); } };", CallOnVariableY));
1205  EXPECT_TRUE(matches(
1206      "class Y { public: void x() const { Y y; y.x(); } };", CallOnVariableY));
1207  EXPECT_TRUE(matches(
1208      "class Y { public: void x(); };"
1209      "class X : public Y { void z() { X y; y.x(); } };", CallOnVariableY));
1210  EXPECT_TRUE(matches(
1211      "class Y { public: void x(); };"
1212      "class X : public Y { void z() { X *y; y->x(); } };", CallOnVariableY));
1213  EXPECT_TRUE(notMatches(
1214      "class Y { public: void x(); };"
1215      "class X : public Y { void z() { unsigned long y; ((X*)y)->x(); } };",
1216      CallOnVariableY));
1217}
1218
1219TEST(UnaryExprOrTypeTraitExpr, MatchesSizeOfAndAlignOf) {
1220  EXPECT_TRUE(matches("void x() { int a = sizeof(a); }",
1221                      unaryExprOrTypeTraitExpr()));
1222  EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }",
1223                         alignOfExpr(anything())));
1224  // FIXME: Uncomment once alignof is enabled.
1225  // EXPECT_TRUE(matches("void x() { int a = alignof(a); }",
1226  //                     unaryExprOrTypeTraitExpr()));
1227  // EXPECT_TRUE(notMatches("void x() { int a = alignof(a); }",
1228  //                        sizeOfExpr()));
1229}
1230
1231TEST(UnaryExpressionOrTypeTraitExpression, MatchesCorrectType) {
1232  EXPECT_TRUE(matches("void x() { int a = sizeof(a); }", sizeOfExpr(
1233      hasArgumentOfType(asString("int")))));
1234  EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
1235      hasArgumentOfType(asString("float")))));
1236  EXPECT_TRUE(matches(
1237      "struct A {}; void x() { A a; int b = sizeof(a); }",
1238      sizeOfExpr(hasArgumentOfType(hasDeclaration(recordDecl(hasName("A")))))));
1239  EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
1240      hasArgumentOfType(hasDeclaration(recordDecl(hasName("string")))))));
1241}
1242
1243TEST(MemberExpression, DoesNotMatchClasses) {
1244  EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpr()));
1245}
1246
1247TEST(MemberExpression, MatchesMemberFunctionCall) {
1248  EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpr()));
1249}
1250
1251TEST(MemberExpression, MatchesVariable) {
1252  EXPECT_TRUE(
1253      matches("class Y { void x() { this->y; } int y; };", memberExpr()));
1254  EXPECT_TRUE(
1255      matches("class Y { void x() { y; } int y; };", memberExpr()));
1256  EXPECT_TRUE(
1257      matches("class Y { void x() { Y y; y.y; } int y; };", memberExpr()));
1258}
1259
1260TEST(MemberExpression, MatchesStaticVariable) {
1261  EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
1262              memberExpr()));
1263  EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
1264              memberExpr()));
1265  EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
1266              memberExpr()));
1267}
1268
1269TEST(IsInteger, MatchesIntegers) {
1270  EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isInteger()))));
1271  EXPECT_TRUE(matches(
1272      "long long i = 0; void f(long long) { }; void g() {f(i);}",
1273      callExpr(hasArgument(0, declRefExpr(
1274                                  to(varDecl(hasType(isInteger()))))))));
1275}
1276
1277TEST(IsInteger, ReportsNoFalsePositives) {
1278  EXPECT_TRUE(notMatches("int *i;", varDecl(hasType(isInteger()))));
1279  EXPECT_TRUE(notMatches("struct T {}; T t; void f(T *) { }; void g() {f(&t);}",
1280                      callExpr(hasArgument(0, declRefExpr(
1281                          to(varDecl(hasType(isInteger()))))))));
1282}
1283
1284TEST(IsArrow, MatchesMemberVariablesViaArrow) {
1285  EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
1286              memberExpr(isArrow())));
1287  EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
1288              memberExpr(isArrow())));
1289  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
1290              memberExpr(isArrow())));
1291}
1292
1293TEST(IsArrow, MatchesStaticMemberVariablesViaArrow) {
1294  EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
1295              memberExpr(isArrow())));
1296  EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
1297              memberExpr(isArrow())));
1298  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
1299              memberExpr(isArrow())));
1300}
1301
1302TEST(IsArrow, MatchesMemberCallsViaArrow) {
1303  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
1304              memberExpr(isArrow())));
1305  EXPECT_TRUE(matches("class Y { void x() { x(); } };",
1306              memberExpr(isArrow())));
1307  EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
1308              memberExpr(isArrow())));
1309}
1310
1311TEST(Callee, MatchesDeclarations) {
1312  StatementMatcher CallMethodX = callExpr(callee(methodDecl(hasName("x"))));
1313
1314  EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
1315  EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
1316}
1317
1318TEST(Callee, MatchesMemberExpressions) {
1319  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
1320              callExpr(callee(memberExpr()))));
1321  EXPECT_TRUE(
1322      notMatches("class Y { void x() { this->x(); } };", callExpr(callee(callExpr()))));
1323}
1324
1325TEST(Function, MatchesFunctionDeclarations) {
1326  StatementMatcher CallFunctionF = callExpr(callee(functionDecl(hasName("f"))));
1327
1328  EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
1329  EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
1330
1331  if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
1332      llvm::Triple::Win32) {
1333    // FIXME: Make this work for MSVC.
1334    // Dependent contexts, but a non-dependent call.
1335    EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
1336                        CallFunctionF));
1337    EXPECT_TRUE(
1338        matches("void f(); template <int N> struct S { void g() { f(); } };",
1339                CallFunctionF));
1340  }
1341
1342  // Depedent calls don't match.
1343  EXPECT_TRUE(
1344      notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
1345                 CallFunctionF));
1346  EXPECT_TRUE(
1347      notMatches("void f(int);"
1348                 "template <typename T> struct S { void g(T t) { f(t); } };",
1349                 CallFunctionF));
1350}
1351
1352TEST(FunctionTemplate, MatchesFunctionTemplateDeclarations) {
1353  EXPECT_TRUE(
1354      matches("template <typename T> void f(T t) {}",
1355      functionTemplateDecl(hasName("f"))));
1356}
1357
1358TEST(FunctionTemplate, DoesNotMatchFunctionDeclarations) {
1359  EXPECT_TRUE(
1360      notMatches("void f(double d); void f(int t) {}",
1361      functionTemplateDecl(hasName("f"))));
1362}
1363
1364TEST(FunctionTemplate, DoesNotMatchFunctionTemplateSpecializations) {
1365  EXPECT_TRUE(
1366      notMatches("void g(); template <typename T> void f(T t) {}"
1367                 "template <> void f(int t) { g(); }",
1368      functionTemplateDecl(hasName("f"),
1369                           hasDescendant(declRefExpr(to(
1370                               functionDecl(hasName("g"))))))));
1371}
1372
1373TEST(Matcher, Argument) {
1374  StatementMatcher CallArgumentY = callExpr(
1375      hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
1376
1377  EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
1378  EXPECT_TRUE(
1379      matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
1380  EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
1381
1382  StatementMatcher WrongIndex = callExpr(
1383      hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
1384  EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
1385}
1386
1387TEST(Matcher, AnyArgument) {
1388  StatementMatcher CallArgumentY = callExpr(
1389      hasAnyArgument(declRefExpr(to(varDecl(hasName("y"))))));
1390  EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
1391  EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
1392  EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
1393}
1394
1395TEST(Matcher, ArgumentCount) {
1396  StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
1397
1398  EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
1399  EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
1400  EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
1401}
1402
1403TEST(Matcher, ParameterCount) {
1404  DeclarationMatcher Function1Arg = functionDecl(parameterCountIs(1));
1405  EXPECT_TRUE(matches("void f(int i) {}", Function1Arg));
1406  EXPECT_TRUE(matches("class X { void f(int i) {} };", Function1Arg));
1407  EXPECT_TRUE(notMatches("void f() {}", Function1Arg));
1408  EXPECT_TRUE(notMatches("void f(int i, int j, int k) {}", Function1Arg));
1409}
1410
1411TEST(Matcher, References) {
1412  DeclarationMatcher ReferenceClassX = varDecl(
1413      hasType(references(recordDecl(hasName("X")))));
1414  EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
1415                      ReferenceClassX));
1416  EXPECT_TRUE(
1417      matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
1418  // The match here is on the implicit copy constructor code for
1419  // class X, not on code 'X x = y'.
1420  EXPECT_TRUE(
1421      matches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
1422  EXPECT_TRUE(
1423      notMatches("class X {}; extern X x;", ReferenceClassX));
1424  EXPECT_TRUE(
1425      notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
1426}
1427
1428TEST(QualType, hasCanonicalType) {
1429  EXPECT_TRUE(notMatches("typedef int &int_ref;"
1430                         "int a;"
1431                         "int_ref b = a;",
1432                         varDecl(hasType(qualType(referenceType())))));
1433  EXPECT_TRUE(
1434      matches("typedef int &int_ref;"
1435              "int a;"
1436              "int_ref b = a;",
1437              varDecl(hasType(qualType(hasCanonicalType(referenceType()))))));
1438}
1439
1440TEST(QualType, hasLocalQualifiers) {
1441  EXPECT_TRUE(notMatches("typedef const int const_int; const_int i = 1;",
1442                         varDecl(hasType(hasLocalQualifiers()))));
1443  EXPECT_TRUE(matches("int *const j = nullptr;",
1444                      varDecl(hasType(hasLocalQualifiers()))));
1445  EXPECT_TRUE(matches("int *volatile k;",
1446                      varDecl(hasType(hasLocalQualifiers()))));
1447  EXPECT_TRUE(notMatches("int m;",
1448                         varDecl(hasType(hasLocalQualifiers()))));
1449}
1450
1451TEST(HasParameter, CallsInnerMatcher) {
1452  EXPECT_TRUE(matches("class X { void x(int) {} };",
1453      methodDecl(hasParameter(0, varDecl()))));
1454  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
1455      methodDecl(hasParameter(0, hasName("x")))));
1456}
1457
1458TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
1459  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
1460      methodDecl(hasParameter(42, varDecl()))));
1461}
1462
1463TEST(HasType, MatchesParameterVariableTypesStrictly) {
1464  EXPECT_TRUE(matches("class X { void x(X x) {} };",
1465      methodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
1466  EXPECT_TRUE(notMatches("class X { void x(const X &x) {} };",
1467      methodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
1468  EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
1469      methodDecl(hasParameter(0,
1470                              hasType(pointsTo(recordDecl(hasName("X"))))))));
1471  EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
1472      methodDecl(hasParameter(0,
1473                              hasType(references(recordDecl(hasName("X"))))))));
1474}
1475
1476TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
1477  EXPECT_TRUE(matches("class Y {}; class X { void x(X x, Y y) {} };",
1478      methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
1479  EXPECT_TRUE(matches("class Y {}; class X { void x(Y y, X x) {} };",
1480      methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
1481}
1482
1483TEST(Returns, MatchesReturnTypes) {
1484  EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
1485                      functionDecl(returns(asString("int")))));
1486  EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
1487                         functionDecl(returns(asString("float")))));
1488  EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
1489                      functionDecl(returns(hasDeclaration(
1490                          recordDecl(hasName("Y")))))));
1491}
1492
1493TEST(IsExternC, MatchesExternCFunctionDeclarations) {
1494  EXPECT_TRUE(matches("extern \"C\" void f() {}", functionDecl(isExternC())));
1495  EXPECT_TRUE(matches("extern \"C\" { void f() {} }",
1496              functionDecl(isExternC())));
1497  EXPECT_TRUE(notMatches("void f() {}", functionDecl(isExternC())));
1498}
1499
1500TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
1501  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
1502      methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
1503}
1504
1505TEST(HasAnyParameter, DoesNotMatchThisPointer) {
1506  EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
1507      methodDecl(hasAnyParameter(hasType(pointsTo(
1508          recordDecl(hasName("X"))))))));
1509}
1510
1511TEST(HasName, MatchesParameterVariableDeclarations) {
1512  EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
1513      methodDecl(hasAnyParameter(hasName("x")))));
1514  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
1515      methodDecl(hasAnyParameter(hasName("x")))));
1516}
1517
1518TEST(Matcher, MatchesClassTemplateSpecialization) {
1519  EXPECT_TRUE(matches("template<typename T> struct A {};"
1520                      "template<> struct A<int> {};",
1521                      classTemplateSpecializationDecl()));
1522  EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
1523                      classTemplateSpecializationDecl()));
1524  EXPECT_TRUE(notMatches("template<typename T> struct A {};",
1525                         classTemplateSpecializationDecl()));
1526}
1527
1528TEST(DeclaratorDecl, MatchesDeclaratorDecls) {
1529  EXPECT_TRUE(matches("int x;", declaratorDecl()));
1530  EXPECT_TRUE(notMatches("class A {};", declaratorDecl()));
1531}
1532
1533TEST(ParmVarDecl, MatchesParmVars) {
1534  EXPECT_TRUE(matches("void f(int x);", parmVarDecl()));
1535  EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
1536}
1537
1538TEST(Matcher, MatchesTypeTemplateArgument) {
1539  EXPECT_TRUE(matches(
1540      "template<typename T> struct B {};"
1541      "B<int> b;",
1542      classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
1543          asString("int"))))));
1544}
1545
1546TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
1547  EXPECT_TRUE(matches(
1548      "struct B { int next; };"
1549      "template<int(B::*next_ptr)> struct A {};"
1550      "A<&B::next> a;",
1551      classTemplateSpecializationDecl(hasAnyTemplateArgument(
1552          refersToDeclaration(fieldDecl(hasName("next")))))));
1553
1554  EXPECT_TRUE(notMatches(
1555      "template <typename T> struct A {};"
1556      "A<int> a;",
1557      classTemplateSpecializationDecl(hasAnyTemplateArgument(
1558          refersToDeclaration(decl())))));
1559
1560  EXPECT_TRUE(matches(
1561      "struct B { int next; };"
1562      "template<int(B::*next_ptr)> struct A {};"
1563      "A<&B::next> a;",
1564      templateSpecializationType(hasAnyTemplateArgument(isExpr(
1565          hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))));
1566
1567  EXPECT_TRUE(notMatches(
1568      "template <typename T> struct A {};"
1569      "A<int> a;",
1570      templateSpecializationType(hasAnyTemplateArgument(
1571          refersToDeclaration(decl())))));
1572}
1573
1574TEST(Matcher, MatchesSpecificArgument) {
1575  EXPECT_TRUE(matches(
1576      "template<typename T, typename U> class A {};"
1577      "A<bool, int> a;",
1578      classTemplateSpecializationDecl(hasTemplateArgument(
1579          1, refersToType(asString("int"))))));
1580  EXPECT_TRUE(notMatches(
1581      "template<typename T, typename U> class A {};"
1582      "A<int, bool> a;",
1583      classTemplateSpecializationDecl(hasTemplateArgument(
1584          1, refersToType(asString("int"))))));
1585
1586  EXPECT_TRUE(matches(
1587      "template<typename T, typename U> class A {};"
1588      "A<bool, int> a;",
1589      templateSpecializationType(hasTemplateArgument(
1590          1, refersToType(asString("int"))))));
1591  EXPECT_TRUE(notMatches(
1592      "template<typename T, typename U> class A {};"
1593      "A<int, bool> a;",
1594      templateSpecializationType(hasTemplateArgument(
1595          1, refersToType(asString("int"))))));
1596}
1597
1598TEST(Matcher, MatchesAccessSpecDecls) {
1599  EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));
1600  EXPECT_TRUE(
1601      matches("class C { public: int i; };", accessSpecDecl(isPublic())));
1602  EXPECT_TRUE(
1603      notMatches("class C { public: int i; };", accessSpecDecl(isProtected())));
1604  EXPECT_TRUE(
1605      notMatches("class C { public: int i; };", accessSpecDecl(isPrivate())));
1606
1607  EXPECT_TRUE(notMatches("class C { int i; };", accessSpecDecl()));
1608}
1609
1610TEST(Matcher, MatchesVirtualMethod) {
1611  EXPECT_TRUE(matches("class X { virtual int f(); };",
1612      methodDecl(isVirtual(), hasName("::X::f"))));
1613  EXPECT_TRUE(notMatches("class X { int f(); };",
1614      methodDecl(isVirtual())));
1615}
1616
1617TEST(Matcher, MatchesPureMethod) {
1618  EXPECT_TRUE(matches("class X { virtual int f() = 0; };",
1619      methodDecl(isPure(), hasName("::X::f"))));
1620  EXPECT_TRUE(notMatches("class X { int f(); };",
1621      methodDecl(isPure())));
1622}
1623
1624TEST(Matcher, MatchesConstMethod) {
1625  EXPECT_TRUE(matches("struct A { void foo() const; };",
1626                      methodDecl(isConst())));
1627  EXPECT_TRUE(notMatches("struct A { void foo(); };",
1628                         methodDecl(isConst())));
1629}
1630
1631TEST(Matcher, MatchesOverridingMethod) {
1632  EXPECT_TRUE(matches("class X { virtual int f(); }; "
1633                      "class Y : public X { int f(); };",
1634       methodDecl(isOverride(), hasName("::Y::f"))));
1635  EXPECT_TRUE(notMatches("class X { virtual int f(); }; "
1636                        "class Y : public X { int f(); };",
1637       methodDecl(isOverride(), hasName("::X::f"))));
1638  EXPECT_TRUE(notMatches("class X { int f(); }; "
1639                         "class Y : public X { int f(); };",
1640       methodDecl(isOverride())));
1641  EXPECT_TRUE(notMatches("class X { int f(); int f(int); }; ",
1642       methodDecl(isOverride())));
1643}
1644
1645TEST(Matcher, ConstructorCall) {
1646  StatementMatcher Constructor = constructExpr();
1647
1648  EXPECT_TRUE(
1649      matches("class X { public: X(); }; void x() { X x; }", Constructor));
1650  EXPECT_TRUE(
1651      matches("class X { public: X(); }; void x() { X x = X(); }",
1652              Constructor));
1653  EXPECT_TRUE(
1654      matches("class X { public: X(int); }; void x() { X x = 0; }",
1655              Constructor));
1656  EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
1657}
1658
1659TEST(Matcher, ConstructorArgument) {
1660  StatementMatcher Constructor = constructExpr(
1661      hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
1662
1663  EXPECT_TRUE(
1664      matches("class X { public: X(int); }; void x() { int y; X x(y); }",
1665              Constructor));
1666  EXPECT_TRUE(
1667      matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
1668              Constructor));
1669  EXPECT_TRUE(
1670      matches("class X { public: X(int); }; void x() { int y; X x = y; }",
1671              Constructor));
1672  EXPECT_TRUE(
1673      notMatches("class X { public: X(int); }; void x() { int z; X x(z); }",
1674                 Constructor));
1675
1676  StatementMatcher WrongIndex = constructExpr(
1677      hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
1678  EXPECT_TRUE(
1679      notMatches("class X { public: X(int); }; void x() { int y; X x(y); }",
1680                 WrongIndex));
1681}
1682
1683TEST(Matcher, ConstructorArgumentCount) {
1684  StatementMatcher Constructor1Arg = constructExpr(argumentCountIs(1));
1685
1686  EXPECT_TRUE(
1687      matches("class X { public: X(int); }; void x() { X x(0); }",
1688              Constructor1Arg));
1689  EXPECT_TRUE(
1690      matches("class X { public: X(int); }; void x() { X x = X(0); }",
1691              Constructor1Arg));
1692  EXPECT_TRUE(
1693      matches("class X { public: X(int); }; void x() { X x = 0; }",
1694              Constructor1Arg));
1695  EXPECT_TRUE(
1696      notMatches("class X { public: X(int, int); }; void x() { X x(0, 0); }",
1697                 Constructor1Arg));
1698}
1699
1700TEST(Matcher, ConstructorListInitialization) {
1701  StatementMatcher ConstructorListInit = constructExpr(isListInitialization());
1702
1703  EXPECT_TRUE(
1704      matches("class X { public: X(int); }; void x() { X x{0}; }",
1705              ConstructorListInit));
1706  EXPECT_FALSE(
1707      matches("class X { public: X(int); }; void x() { X x(0); }",
1708              ConstructorListInit));
1709}
1710
1711TEST(Matcher,ThisExpr) {
1712  EXPECT_TRUE(
1713      matches("struct X { int a; int f () { return a; } };", thisExpr()));
1714  EXPECT_TRUE(
1715      notMatches("struct X { int f () { int a; return a; } };", thisExpr()));
1716}
1717
1718TEST(Matcher, BindTemporaryExpression) {
1719  StatementMatcher TempExpression = bindTemporaryExpr();
1720
1721  std::string ClassString = "class string { public: string(); ~string(); }; ";
1722
1723  EXPECT_TRUE(
1724      matches(ClassString +
1725              "string GetStringByValue();"
1726              "void FunctionTakesString(string s);"
1727              "void run() { FunctionTakesString(GetStringByValue()); }",
1728              TempExpression));
1729
1730  EXPECT_TRUE(
1731      notMatches(ClassString +
1732                 "string* GetStringPointer(); "
1733                 "void FunctionTakesStringPtr(string* s);"
1734                 "void run() {"
1735                 "  string* s = GetStringPointer();"
1736                 "  FunctionTakesStringPtr(GetStringPointer());"
1737                 "  FunctionTakesStringPtr(s);"
1738                 "}",
1739                 TempExpression));
1740
1741  EXPECT_TRUE(
1742      notMatches("class no_dtor {};"
1743                 "no_dtor GetObjByValue();"
1744                 "void ConsumeObj(no_dtor param);"
1745                 "void run() { ConsumeObj(GetObjByValue()); }",
1746                 TempExpression));
1747}
1748
1749TEST(MaterializeTemporaryExpr, MatchesTemporary) {
1750  std::string ClassString =
1751      "class string { public: string(); int length(); }; ";
1752
1753  EXPECT_TRUE(
1754      matches(ClassString +
1755              "string GetStringByValue();"
1756              "void FunctionTakesString(string s);"
1757              "void run() { FunctionTakesString(GetStringByValue()); }",
1758              materializeTemporaryExpr()));
1759
1760  EXPECT_TRUE(
1761      notMatches(ClassString +
1762                 "string* GetStringPointer(); "
1763                 "void FunctionTakesStringPtr(string* s);"
1764                 "void run() {"
1765                 "  string* s = GetStringPointer();"
1766                 "  FunctionTakesStringPtr(GetStringPointer());"
1767                 "  FunctionTakesStringPtr(s);"
1768                 "}",
1769                 materializeTemporaryExpr()));
1770
1771  EXPECT_TRUE(
1772      notMatches(ClassString +
1773                 "string GetStringByValue();"
1774                 "void run() { int k = GetStringByValue().length(); }",
1775                 materializeTemporaryExpr()));
1776
1777  EXPECT_TRUE(
1778      notMatches(ClassString +
1779                 "string GetStringByValue();"
1780                 "void run() { GetStringByValue(); }",
1781                 materializeTemporaryExpr()));
1782}
1783
1784TEST(ConstructorDeclaration, SimpleCase) {
1785  EXPECT_TRUE(matches("class Foo { Foo(int i); };",
1786                      constructorDecl(ofClass(hasName("Foo")))));
1787  EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
1788                         constructorDecl(ofClass(hasName("Bar")))));
1789}
1790
1791TEST(ConstructorDeclaration, IsImplicit) {
1792  // This one doesn't match because the constructor is not added by the
1793  // compiler (it is not needed).
1794  EXPECT_TRUE(notMatches("class Foo { };",
1795                         constructorDecl(isImplicit())));
1796  // The compiler added the implicit default constructor.
1797  EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
1798                      constructorDecl(isImplicit())));
1799  EXPECT_TRUE(matches("class Foo { Foo(){} };",
1800                      constructorDecl(unless(isImplicit()))));
1801  // The compiler added an implicit assignment operator.
1802  EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
1803                      methodDecl(isImplicit(), hasName("operator="))));
1804}
1805
1806TEST(DestructorDeclaration, MatchesVirtualDestructor) {
1807  EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
1808                      destructorDecl(ofClass(hasName("Foo")))));
1809}
1810
1811TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {
1812  EXPECT_TRUE(notMatches("class Foo {};",
1813                         destructorDecl(ofClass(hasName("Foo")))));
1814}
1815
1816TEST(HasAnyConstructorInitializer, SimpleCase) {
1817  EXPECT_TRUE(notMatches(
1818      "class Foo { Foo() { } };",
1819      constructorDecl(hasAnyConstructorInitializer(anything()))));
1820  EXPECT_TRUE(matches(
1821      "class Foo {"
1822      "  Foo() : foo_() { }"
1823      "  int foo_;"
1824      "};",
1825      constructorDecl(hasAnyConstructorInitializer(anything()))));
1826}
1827
1828TEST(HasAnyConstructorInitializer, ForField) {
1829  static const char Code[] =
1830      "class Baz { };"
1831      "class Foo {"
1832      "  Foo() : foo_() { }"
1833      "  Baz foo_;"
1834      "  Baz bar_;"
1835      "};";
1836  EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1837      forField(hasType(recordDecl(hasName("Baz"))))))));
1838  EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1839      forField(hasName("foo_"))))));
1840  EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
1841      forField(hasType(recordDecl(hasName("Bar"))))))));
1842}
1843
1844TEST(HasAnyConstructorInitializer, WithInitializer) {
1845  static const char Code[] =
1846      "class Foo {"
1847      "  Foo() : foo_(0) { }"
1848      "  int foo_;"
1849      "};";
1850  EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1851      withInitializer(integerLiteral(equals(0)))))));
1852  EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
1853      withInitializer(integerLiteral(equals(1)))))));
1854}
1855
1856TEST(HasAnyConstructorInitializer, IsWritten) {
1857  static const char Code[] =
1858      "struct Bar { Bar(){} };"
1859      "class Foo {"
1860      "  Foo() : foo_() { }"
1861      "  Bar foo_;"
1862      "  Bar bar_;"
1863      "};";
1864  EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1865      allOf(forField(hasName("foo_")), isWritten())))));
1866  EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
1867      allOf(forField(hasName("bar_")), isWritten())))));
1868  EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1869      allOf(forField(hasName("bar_")), unless(isWritten()))))));
1870}
1871
1872TEST(Matcher, NewExpression) {
1873  StatementMatcher New = newExpr();
1874
1875  EXPECT_TRUE(matches("class X { public: X(); }; void x() { new X; }", New));
1876  EXPECT_TRUE(
1877      matches("class X { public: X(); }; void x() { new X(); }", New));
1878  EXPECT_TRUE(
1879      matches("class X { public: X(int); }; void x() { new X(0); }", New));
1880  EXPECT_TRUE(matches("class X {}; void x(int) { new X; }", New));
1881}
1882
1883TEST(Matcher, NewExpressionArgument) {
1884  StatementMatcher New = constructExpr(
1885      hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
1886
1887  EXPECT_TRUE(
1888      matches("class X { public: X(int); }; void x() { int y; new X(y); }",
1889              New));
1890  EXPECT_TRUE(
1891      matches("class X { public: X(int); }; void x() { int y; new X(y); }",
1892              New));
1893  EXPECT_TRUE(
1894      notMatches("class X { public: X(int); }; void x() { int z; new X(z); }",
1895                 New));
1896
1897  StatementMatcher WrongIndex = constructExpr(
1898      hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
1899  EXPECT_TRUE(
1900      notMatches("class X { public: X(int); }; void x() { int y; new X(y); }",
1901                 WrongIndex));
1902}
1903
1904TEST(Matcher, NewExpressionArgumentCount) {
1905  StatementMatcher New = constructExpr(argumentCountIs(1));
1906
1907  EXPECT_TRUE(
1908      matches("class X { public: X(int); }; void x() { new X(0); }", New));
1909  EXPECT_TRUE(
1910      notMatches("class X { public: X(int, int); }; void x() { new X(0, 0); }",
1911                 New));
1912}
1913
1914TEST(Matcher, DeleteExpression) {
1915  EXPECT_TRUE(matches("struct A {}; void f(A* a) { delete a; }",
1916                      deleteExpr()));
1917}
1918
1919TEST(Matcher, DefaultArgument) {
1920  StatementMatcher Arg = defaultArgExpr();
1921
1922  EXPECT_TRUE(matches("void x(int, int = 0) { int y; x(y); }", Arg));
1923  EXPECT_TRUE(
1924      matches("class X { void x(int, int = 0) { int y; x(y); } };", Arg));
1925  EXPECT_TRUE(notMatches("void x(int, int = 0) { int y; x(y, 0); }", Arg));
1926}
1927
1928TEST(Matcher, StringLiterals) {
1929  StatementMatcher Literal = stringLiteral();
1930  EXPECT_TRUE(matches("const char *s = \"string\";", Literal));
1931  // wide string
1932  EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", Literal));
1933  // with escaped characters
1934  EXPECT_TRUE(matches("const char *s = \"\x05five\";", Literal));
1935  // no matching -- though the data type is the same, there is no string literal
1936  EXPECT_TRUE(notMatches("const char s[1] = {'a'};", Literal));
1937}
1938
1939TEST(Matcher, CharacterLiterals) {
1940  StatementMatcher CharLiteral = characterLiteral();
1941  EXPECT_TRUE(matches("const char c = 'c';", CharLiteral));
1942  // wide character
1943  EXPECT_TRUE(matches("const char c = L'c';", CharLiteral));
1944  // wide character, Hex encoded, NOT MATCHED!
1945  EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", CharLiteral));
1946  EXPECT_TRUE(notMatches("const char c = 0x1;", CharLiteral));
1947}
1948
1949TEST(Matcher, IntegerLiterals) {
1950  StatementMatcher HasIntLiteral = integerLiteral();
1951  EXPECT_TRUE(matches("int i = 10;", HasIntLiteral));
1952  EXPECT_TRUE(matches("int i = 0x1AB;", HasIntLiteral));
1953  EXPECT_TRUE(matches("int i = 10L;", HasIntLiteral));
1954  EXPECT_TRUE(matches("int i = 10U;", HasIntLiteral));
1955
1956  // Non-matching cases (character literals, float and double)
1957  EXPECT_TRUE(notMatches("int i = L'a';",
1958                HasIntLiteral));  // this is actually a character
1959                                  // literal cast to int
1960  EXPECT_TRUE(notMatches("int i = 'a';", HasIntLiteral));
1961  EXPECT_TRUE(notMatches("int i = 1e10;", HasIntLiteral));
1962  EXPECT_TRUE(notMatches("int i = 10.0;", HasIntLiteral));
1963}
1964
1965TEST(Matcher, FloatLiterals) {
1966  StatementMatcher HasFloatLiteral = floatLiteral();
1967  EXPECT_TRUE(matches("float i = 10.0;", HasFloatLiteral));
1968  EXPECT_TRUE(matches("float i = 10.0f;", HasFloatLiteral));
1969  EXPECT_TRUE(matches("double i = 10.0;", HasFloatLiteral));
1970  EXPECT_TRUE(matches("double i = 10.0L;", HasFloatLiteral));
1971  EXPECT_TRUE(matches("double i = 1e10;", HasFloatLiteral));
1972
1973  EXPECT_TRUE(notMatches("float i = 10;", HasFloatLiteral));
1974}
1975
1976TEST(Matcher, NullPtrLiteral) {
1977  EXPECT_TRUE(matches("int* i = nullptr;", nullPtrLiteralExpr()));
1978}
1979
1980TEST(Matcher, AsmStatement) {
1981  EXPECT_TRUE(matches("void foo() { __asm(\"mov al, 2\"); }", asmStmt()));
1982}
1983
1984TEST(Matcher, Conditions) {
1985  StatementMatcher Condition = ifStmt(hasCondition(boolLiteral(equals(true))));
1986
1987  EXPECT_TRUE(matches("void x() { if (true) {} }", Condition));
1988  EXPECT_TRUE(notMatches("void x() { if (false) {} }", Condition));
1989  EXPECT_TRUE(notMatches("void x() { bool a = true; if (a) {} }", Condition));
1990  EXPECT_TRUE(notMatches("void x() { if (true || false) {} }", Condition));
1991  EXPECT_TRUE(notMatches("void x() { if (1) {} }", Condition));
1992}
1993
1994TEST(IfStmt, ChildTraversalMatchers) {
1995  EXPECT_TRUE(matches("void f() { if (false) true; else false; }",
1996                      ifStmt(hasThen(boolLiteral(equals(true))))));
1997  EXPECT_TRUE(notMatches("void f() { if (false) false; else true; }",
1998                         ifStmt(hasThen(boolLiteral(equals(true))))));
1999  EXPECT_TRUE(matches("void f() { if (false) false; else true; }",
2000                      ifStmt(hasElse(boolLiteral(equals(true))))));
2001  EXPECT_TRUE(notMatches("void f() { if (false) true; else false; }",
2002                         ifStmt(hasElse(boolLiteral(equals(true))))));
2003}
2004
2005TEST(MatchBinaryOperator, HasOperatorName) {
2006  StatementMatcher OperatorOr = binaryOperator(hasOperatorName("||"));
2007
2008  EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
2009  EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
2010}
2011
2012TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
2013  StatementMatcher OperatorTrueFalse =
2014      binaryOperator(hasLHS(boolLiteral(equals(true))),
2015                     hasRHS(boolLiteral(equals(false))));
2016
2017  EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
2018  EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
2019  EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
2020}
2021
2022TEST(MatchBinaryOperator, HasEitherOperand) {
2023  StatementMatcher HasOperand =
2024      binaryOperator(hasEitherOperand(boolLiteral(equals(false))));
2025
2026  EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
2027  EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
2028  EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
2029}
2030
2031TEST(Matcher, BinaryOperatorTypes) {
2032  // Integration test that verifies the AST provides all binary operators in
2033  // a way we expect.
2034  // FIXME: Operator ','
2035  EXPECT_TRUE(
2036      matches("void x() { 3, 4; }", binaryOperator(hasOperatorName(","))));
2037  EXPECT_TRUE(
2038      matches("bool b; bool c = (b = true);",
2039              binaryOperator(hasOperatorName("="))));
2040  EXPECT_TRUE(
2041      matches("bool b = 1 != 2;", binaryOperator(hasOperatorName("!="))));
2042  EXPECT_TRUE(
2043      matches("bool b = 1 == 2;", binaryOperator(hasOperatorName("=="))));
2044  EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
2045  EXPECT_TRUE(
2046      matches("bool b = 1 <= 2;", binaryOperator(hasOperatorName("<="))));
2047  EXPECT_TRUE(
2048      matches("int i = 1 << 2;", binaryOperator(hasOperatorName("<<"))));
2049  EXPECT_TRUE(
2050      matches("int i = 1; int j = (i <<= 2);",
2051              binaryOperator(hasOperatorName("<<="))));
2052  EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
2053  EXPECT_TRUE(
2054      matches("bool b = 1 >= 2;", binaryOperator(hasOperatorName(">="))));
2055  EXPECT_TRUE(
2056      matches("int i = 1 >> 2;", binaryOperator(hasOperatorName(">>"))));
2057  EXPECT_TRUE(
2058      matches("int i = 1; int j = (i >>= 2);",
2059              binaryOperator(hasOperatorName(">>="))));
2060  EXPECT_TRUE(
2061      matches("int i = 42 ^ 23;", binaryOperator(hasOperatorName("^"))));
2062  EXPECT_TRUE(
2063      matches("int i = 42; int j = (i ^= 42);",
2064              binaryOperator(hasOperatorName("^="))));
2065  EXPECT_TRUE(
2066      matches("int i = 42 % 23;", binaryOperator(hasOperatorName("%"))));
2067  EXPECT_TRUE(
2068      matches("int i = 42; int j = (i %= 42);",
2069              binaryOperator(hasOperatorName("%="))));
2070  EXPECT_TRUE(
2071      matches("bool b = 42  &23;", binaryOperator(hasOperatorName("&"))));
2072  EXPECT_TRUE(
2073      matches("bool b = true && false;",
2074              binaryOperator(hasOperatorName("&&"))));
2075  EXPECT_TRUE(
2076      matches("bool b = true; bool c = (b &= false);",
2077              binaryOperator(hasOperatorName("&="))));
2078  EXPECT_TRUE(
2079      matches("bool b = 42 | 23;", binaryOperator(hasOperatorName("|"))));
2080  EXPECT_TRUE(
2081      matches("bool b = true || false;",
2082              binaryOperator(hasOperatorName("||"))));
2083  EXPECT_TRUE(
2084      matches("bool b = true; bool c = (b |= false);",
2085              binaryOperator(hasOperatorName("|="))));
2086  EXPECT_TRUE(
2087      matches("int i = 42  *23;", binaryOperator(hasOperatorName("*"))));
2088  EXPECT_TRUE(
2089      matches("int i = 42; int j = (i *= 23);",
2090              binaryOperator(hasOperatorName("*="))));
2091  EXPECT_TRUE(
2092      matches("int i = 42 / 23;", binaryOperator(hasOperatorName("/"))));
2093  EXPECT_TRUE(
2094      matches("int i = 42; int j = (i /= 23);",
2095              binaryOperator(hasOperatorName("/="))));
2096  EXPECT_TRUE(
2097      matches("int i = 42 + 23;", binaryOperator(hasOperatorName("+"))));
2098  EXPECT_TRUE(
2099      matches("int i = 42; int j = (i += 23);",
2100              binaryOperator(hasOperatorName("+="))));
2101  EXPECT_TRUE(
2102      matches("int i = 42 - 23;", binaryOperator(hasOperatorName("-"))));
2103  EXPECT_TRUE(
2104      matches("int i = 42; int j = (i -= 23);",
2105              binaryOperator(hasOperatorName("-="))));
2106  EXPECT_TRUE(
2107      matches("struct A { void x() { void (A::*a)(); (this->*a)(); } };",
2108              binaryOperator(hasOperatorName("->*"))));
2109  EXPECT_TRUE(
2110      matches("struct A { void x() { void (A::*a)(); ((*this).*a)(); } };",
2111              binaryOperator(hasOperatorName(".*"))));
2112
2113  // Member expressions as operators are not supported in matches.
2114  EXPECT_TRUE(
2115      notMatches("struct A { void x(A *a) { a->x(this); } };",
2116                 binaryOperator(hasOperatorName("->"))));
2117
2118  // Initializer assignments are not represented as operator equals.
2119  EXPECT_TRUE(
2120      notMatches("bool b = true;", binaryOperator(hasOperatorName("="))));
2121
2122  // Array indexing is not represented as operator.
2123  EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));
2124
2125  // Overloaded operators do not match at all.
2126  EXPECT_TRUE(notMatches(
2127      "struct A { bool operator&&(const A &a) const { return false; } };"
2128      "void x() { A a, b; a && b; }",
2129      binaryOperator()));
2130}
2131
2132TEST(MatchUnaryOperator, HasOperatorName) {
2133  StatementMatcher OperatorNot = unaryOperator(hasOperatorName("!"));
2134
2135  EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
2136  EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
2137}
2138
2139TEST(MatchUnaryOperator, HasUnaryOperand) {
2140  StatementMatcher OperatorOnFalse =
2141      unaryOperator(hasUnaryOperand(boolLiteral(equals(false))));
2142
2143  EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
2144  EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));
2145}
2146
2147TEST(Matcher, UnaryOperatorTypes) {
2148  // Integration test that verifies the AST provides all unary operators in
2149  // a way we expect.
2150  EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
2151  EXPECT_TRUE(
2152      matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
2153  EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
2154  EXPECT_TRUE(
2155      matches("bool *p; bool b = *p;", unaryOperator(hasOperatorName("*"))));
2156  EXPECT_TRUE(
2157      matches("int i; int j = +i;", unaryOperator(hasOperatorName("+"))));
2158  EXPECT_TRUE(
2159      matches("int i; int j = -i;", unaryOperator(hasOperatorName("-"))));
2160  EXPECT_TRUE(
2161      matches("int i; int j = ++i;", unaryOperator(hasOperatorName("++"))));
2162  EXPECT_TRUE(
2163      matches("int i; int j = i++;", unaryOperator(hasOperatorName("++"))));
2164  EXPECT_TRUE(
2165      matches("int i; int j = --i;", unaryOperator(hasOperatorName("--"))));
2166  EXPECT_TRUE(
2167      matches("int i; int j = i--;", unaryOperator(hasOperatorName("--"))));
2168
2169  // We don't match conversion operators.
2170  EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));
2171
2172  // Function calls are not represented as operator.
2173  EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));
2174
2175  // Overloaded operators do not match at all.
2176  // FIXME: We probably want to add that.
2177  EXPECT_TRUE(notMatches(
2178      "struct A { bool operator!() const { return false; } };"
2179      "void x() { A a; !a; }", unaryOperator(hasOperatorName("!"))));
2180}
2181
2182TEST(Matcher, ConditionalOperator) {
2183  StatementMatcher Conditional = conditionalOperator(
2184      hasCondition(boolLiteral(equals(true))),
2185      hasTrueExpression(boolLiteral(equals(false))));
2186
2187  EXPECT_TRUE(matches("void x() { true ? false : true; }", Conditional));
2188  EXPECT_TRUE(notMatches("void x() { false ? false : true; }", Conditional));
2189  EXPECT_TRUE(notMatches("void x() { true ? true : false; }", Conditional));
2190
2191  StatementMatcher ConditionalFalse = conditionalOperator(
2192      hasFalseExpression(boolLiteral(equals(false))));
2193
2194  EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
2195  EXPECT_TRUE(
2196      notMatches("void x() { true ? false : true; }", ConditionalFalse));
2197}
2198
2199TEST(ArraySubscriptMatchers, ArraySubscripts) {
2200  EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 1; }",
2201                      arraySubscriptExpr()));
2202  EXPECT_TRUE(notMatches("int i; void f() { i = 1; }",
2203                         arraySubscriptExpr()));
2204}
2205
2206TEST(ArraySubscriptMatchers, ArrayIndex) {
2207  EXPECT_TRUE(matches(
2208      "int i[2]; void f() { i[1] = 1; }",
2209      arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
2210  EXPECT_TRUE(matches(
2211      "int i[2]; void f() { 1[i] = 1; }",
2212      arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
2213  EXPECT_TRUE(notMatches(
2214      "int i[2]; void f() { i[1] = 1; }",
2215      arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
2216}
2217
2218TEST(ArraySubscriptMatchers, MatchesArrayBase) {
2219  EXPECT_TRUE(matches(
2220      "int i[2]; void f() { i[1] = 2; }",
2221      arraySubscriptExpr(hasBase(implicitCastExpr(
2222          hasSourceExpression(declRefExpr()))))));
2223}
2224
2225TEST(Matcher, HasNameSupportsNamespaces) {
2226  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
2227              recordDecl(hasName("a::b::C"))));
2228  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
2229              recordDecl(hasName("::a::b::C"))));
2230  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
2231              recordDecl(hasName("b::C"))));
2232  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
2233              recordDecl(hasName("C"))));
2234  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2235              recordDecl(hasName("c::b::C"))));
2236  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2237              recordDecl(hasName("a::c::C"))));
2238  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2239              recordDecl(hasName("a::b::A"))));
2240  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2241              recordDecl(hasName("::C"))));
2242  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2243              recordDecl(hasName("::b::C"))));
2244  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2245              recordDecl(hasName("z::a::b::C"))));
2246  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
2247              recordDecl(hasName("a+b::C"))));
2248  EXPECT_TRUE(notMatches("namespace a { namespace b { class AC; } }",
2249              recordDecl(hasName("C"))));
2250}
2251
2252TEST(Matcher, HasNameSupportsOuterClasses) {
2253  EXPECT_TRUE(
2254      matches("class A { class B { class C; }; };",
2255              recordDecl(hasName("A::B::C"))));
2256  EXPECT_TRUE(
2257      matches("class A { class B { class C; }; };",
2258              recordDecl(hasName("::A::B::C"))));
2259  EXPECT_TRUE(
2260      matches("class A { class B { class C; }; };",
2261              recordDecl(hasName("B::C"))));
2262  EXPECT_TRUE(
2263      matches("class A { class B { class C; }; };",
2264              recordDecl(hasName("C"))));
2265  EXPECT_TRUE(
2266      notMatches("class A { class B { class C; }; };",
2267                 recordDecl(hasName("c::B::C"))));
2268  EXPECT_TRUE(
2269      notMatches("class A { class B { class C; }; };",
2270                 recordDecl(hasName("A::c::C"))));
2271  EXPECT_TRUE(
2272      notMatches("class A { class B { class C; }; };",
2273                 recordDecl(hasName("A::B::A"))));
2274  EXPECT_TRUE(
2275      notMatches("class A { class B { class C; }; };",
2276                 recordDecl(hasName("::C"))));
2277  EXPECT_TRUE(
2278      notMatches("class A { class B { class C; }; };",
2279                 recordDecl(hasName("::B::C"))));
2280  EXPECT_TRUE(notMatches("class A { class B { class C; }; };",
2281              recordDecl(hasName("z::A::B::C"))));
2282  EXPECT_TRUE(
2283      notMatches("class A { class B { class C; }; };",
2284                 recordDecl(hasName("A+B::C"))));
2285}
2286
2287TEST(Matcher, IsDefinition) {
2288  DeclarationMatcher DefinitionOfClassA =
2289      recordDecl(hasName("A"), isDefinition());
2290  EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
2291  EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
2292
2293  DeclarationMatcher DefinitionOfVariableA =
2294      varDecl(hasName("a"), isDefinition());
2295  EXPECT_TRUE(matches("int a;", DefinitionOfVariableA));
2296  EXPECT_TRUE(notMatches("extern int a;", DefinitionOfVariableA));
2297
2298  DeclarationMatcher DefinitionOfMethodA =
2299      methodDecl(hasName("a"), isDefinition());
2300  EXPECT_TRUE(matches("class A { void a() {} };", DefinitionOfMethodA));
2301  EXPECT_TRUE(notMatches("class A { void a(); };", DefinitionOfMethodA));
2302}
2303
2304TEST(Matcher, OfClass) {
2305  StatementMatcher Constructor = constructExpr(hasDeclaration(methodDecl(
2306      ofClass(hasName("X")))));
2307
2308  EXPECT_TRUE(
2309      matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
2310  EXPECT_TRUE(
2311      matches("class X { public: X(); }; void x(int) { X x = X(); }",
2312              Constructor));
2313  EXPECT_TRUE(
2314      notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
2315                 Constructor));
2316}
2317
2318TEST(Matcher, VisitsTemplateInstantiations) {
2319  EXPECT_TRUE(matches(
2320      "class A { public: void x(); };"
2321      "template <typename T> class B { public: void y() { T t; t.x(); } };"
2322      "void f() { B<A> b; b.y(); }",
2323      callExpr(callee(methodDecl(hasName("x"))))));
2324
2325  EXPECT_TRUE(matches(
2326      "class A { public: void x(); };"
2327      "class C {"
2328      " public:"
2329      "  template <typename T> class B { public: void y() { T t; t.x(); } };"
2330      "};"
2331      "void f() {"
2332      "  C::B<A> b; b.y();"
2333      "}",
2334      recordDecl(hasName("C"),
2335                 hasDescendant(callExpr(callee(methodDecl(hasName("x"))))))));
2336}
2337
2338TEST(Matcher, HandlesNullQualTypes) {
2339  // FIXME: Add a Type matcher so we can replace uses of this
2340  // variable with Type(True())
2341  const TypeMatcher AnyType = anything();
2342
2343  // We don't really care whether this matcher succeeds; we're testing that
2344  // it completes without crashing.
2345  EXPECT_TRUE(matches(
2346      "struct A { };"
2347      "template <typename T>"
2348      "void f(T t) {"
2349      "  T local_t(t /* this becomes a null QualType in the AST */);"
2350      "}"
2351      "void g() {"
2352      "  f(0);"
2353      "}",
2354      expr(hasType(TypeMatcher(
2355          anyOf(
2356              TypeMatcher(hasDeclaration(anything())),
2357              pointsTo(AnyType),
2358              references(AnyType)
2359              // Other QualType matchers should go here.
2360                ))))));
2361}
2362
2363// For testing AST_MATCHER_P().
2364AST_MATCHER_P(Decl, just, internal::Matcher<Decl>, AMatcher) {
2365  // Make sure all special variables are used: node, match_finder,
2366  // bound_nodes_builder, and the parameter named 'AMatcher'.
2367  return AMatcher.matches(Node, Finder, Builder);
2368}
2369
2370TEST(AstMatcherPMacro, Works) {
2371  DeclarationMatcher HasClassB = just(has(recordDecl(hasName("B")).bind("b")));
2372
2373  EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
2374      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
2375
2376  EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
2377      HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
2378
2379  EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
2380      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
2381}
2382
2383AST_POLYMORPHIC_MATCHER_P(
2384    polymorphicHas,
2385    AST_POLYMORPHIC_SUPPORTED_TYPES_2(Decl, Stmt),
2386    internal::Matcher<Decl>, AMatcher) {
2387  return Finder->matchesChildOf(
2388      Node, AMatcher, Builder,
2389      ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
2390      ASTMatchFinder::BK_First);
2391}
2392
2393TEST(AstPolymorphicMatcherPMacro, Works) {
2394  DeclarationMatcher HasClassB =
2395      polymorphicHas(recordDecl(hasName("B")).bind("b"));
2396
2397  EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
2398      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
2399
2400  EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
2401      HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
2402
2403  EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
2404      HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
2405
2406  StatementMatcher StatementHasClassB =
2407      polymorphicHas(recordDecl(hasName("B")));
2408
2409  EXPECT_TRUE(matches("void x() { class B {}; }", StatementHasClassB));
2410}
2411
2412TEST(For, FindsForLoops) {
2413  EXPECT_TRUE(matches("void f() { for(;;); }", forStmt()));
2414  EXPECT_TRUE(matches("void f() { if(true) for(;;); }", forStmt()));
2415  EXPECT_TRUE(notMatches("int as[] = { 1, 2, 3 };"
2416                         "void f() { for (auto &a : as); }",
2417                         forStmt()));
2418}
2419
2420TEST(For, ForLoopInternals) {
2421  EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
2422                      forStmt(hasCondition(anything()))));
2423  EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
2424                      forStmt(hasLoopInit(anything()))));
2425}
2426
2427TEST(For, ForRangeLoopInternals) {
2428  EXPECT_TRUE(matches("void f(){ int a[] {1, 2}; for (int i : a); }",
2429                      forRangeStmt(hasLoopVariable(anything()))));
2430  EXPECT_TRUE(matches(
2431      "void f(){ int a[] {1, 2}; for (int i : a); }",
2432      forRangeStmt(hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))))));
2433}
2434
2435TEST(For, NegativeForLoopInternals) {
2436  EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
2437                         forStmt(hasCondition(expr()))));
2438  EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
2439                         forStmt(hasLoopInit(anything()))));
2440}
2441
2442TEST(For, ReportsNoFalsePositives) {
2443  EXPECT_TRUE(notMatches("void f() { ; }", forStmt()));
2444  EXPECT_TRUE(notMatches("void f() { if(true); }", forStmt()));
2445}
2446
2447TEST(CompoundStatement, HandlesSimpleCases) {
2448  EXPECT_TRUE(notMatches("void f();", compoundStmt()));
2449  EXPECT_TRUE(matches("void f() {}", compoundStmt()));
2450  EXPECT_TRUE(matches("void f() {{}}", compoundStmt()));
2451}
2452
2453TEST(CompoundStatement, DoesNotMatchEmptyStruct) {
2454  // It's not a compound statement just because there's "{}" in the source
2455  // text. This is an AST search, not grep.
2456  EXPECT_TRUE(notMatches("namespace n { struct S {}; }",
2457              compoundStmt()));
2458  EXPECT_TRUE(matches("namespace n { struct S { void f() {{}} }; }",
2459              compoundStmt()));
2460}
2461
2462TEST(HasBody, FindsBodyOfForWhileDoLoops) {
2463  EXPECT_TRUE(matches("void f() { for(;;) {} }",
2464              forStmt(hasBody(compoundStmt()))));
2465  EXPECT_TRUE(notMatches("void f() { for(;;); }",
2466              forStmt(hasBody(compoundStmt()))));
2467  EXPECT_TRUE(matches("void f() { while(true) {} }",
2468              whileStmt(hasBody(compoundStmt()))));
2469  EXPECT_TRUE(matches("void f() { do {} while(true); }",
2470              doStmt(hasBody(compoundStmt()))));
2471  EXPECT_TRUE(matches("void f() { int p[2]; for (auto x : p) {} }",
2472              forRangeStmt(hasBody(compoundStmt()))));
2473}
2474
2475TEST(HasAnySubstatement, MatchesForTopLevelCompoundStatement) {
2476  // The simplest case: every compound statement is in a function
2477  // definition, and the function body itself must be a compound
2478  // statement.
2479  EXPECT_TRUE(matches("void f() { for (;;); }",
2480              compoundStmt(hasAnySubstatement(forStmt()))));
2481}
2482
2483TEST(HasAnySubstatement, IsNotRecursive) {
2484  // It's really "has any immediate substatement".
2485  EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
2486              compoundStmt(hasAnySubstatement(forStmt()))));
2487}
2488
2489TEST(HasAnySubstatement, MatchesInNestedCompoundStatements) {
2490  EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
2491              compoundStmt(hasAnySubstatement(forStmt()))));
2492}
2493
2494TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
2495  EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
2496              compoundStmt(hasAnySubstatement(forStmt()))));
2497}
2498
2499TEST(StatementCountIs, FindsNoStatementsInAnEmptyCompoundStatement) {
2500  EXPECT_TRUE(matches("void f() { }",
2501              compoundStmt(statementCountIs(0))));
2502  EXPECT_TRUE(notMatches("void f() {}",
2503              compoundStmt(statementCountIs(1))));
2504}
2505
2506TEST(StatementCountIs, AppearsToMatchOnlyOneCount) {
2507  EXPECT_TRUE(matches("void f() { 1; }",
2508              compoundStmt(statementCountIs(1))));
2509  EXPECT_TRUE(notMatches("void f() { 1; }",
2510              compoundStmt(statementCountIs(0))));
2511  EXPECT_TRUE(notMatches("void f() { 1; }",
2512              compoundStmt(statementCountIs(2))));
2513}
2514
2515TEST(StatementCountIs, WorksWithMultipleStatements) {
2516  EXPECT_TRUE(matches("void f() { 1; 2; 3; }",
2517              compoundStmt(statementCountIs(3))));
2518}
2519
2520TEST(StatementCountIs, WorksWithNestedCompoundStatements) {
2521  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
2522              compoundStmt(statementCountIs(1))));
2523  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
2524              compoundStmt(statementCountIs(2))));
2525  EXPECT_TRUE(notMatches("void f() { { 1; } { 1; 2; 3; 4; } }",
2526              compoundStmt(statementCountIs(3))));
2527  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
2528              compoundStmt(statementCountIs(4))));
2529}
2530
2531TEST(Member, WorksInSimplestCase) {
2532  EXPECT_TRUE(matches("struct { int first; } s; int i(s.first);",
2533                      memberExpr(member(hasName("first")))));
2534}
2535
2536TEST(Member, DoesNotMatchTheBaseExpression) {
2537  // Don't pick out the wrong part of the member expression, this should
2538  // be checking the member (name) only.
2539  EXPECT_TRUE(notMatches("struct { int i; } first; int i(first.i);",
2540                         memberExpr(member(hasName("first")))));
2541}
2542
2543TEST(Member, MatchesInMemberFunctionCall) {
2544  EXPECT_TRUE(matches("void f() {"
2545                      "  struct { void first() {}; } s;"
2546                      "  s.first();"
2547                      "};",
2548                      memberExpr(member(hasName("first")))));
2549}
2550
2551TEST(Member, MatchesMember) {
2552  EXPECT_TRUE(matches(
2553      "struct A { int i; }; void f() { A a; a.i = 2; }",
2554      memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
2555  EXPECT_TRUE(notMatches(
2556      "struct A { float f; }; void f() { A a; a.f = 2.0f; }",
2557      memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
2558}
2559
2560TEST(Member, UnderstandsAccess) {
2561  EXPECT_TRUE(matches(
2562      "struct A { int i; };", fieldDecl(isPublic(), hasName("i"))));
2563  EXPECT_TRUE(notMatches(
2564      "struct A { int i; };", fieldDecl(isProtected(), hasName("i"))));
2565  EXPECT_TRUE(notMatches(
2566      "struct A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
2567
2568  EXPECT_TRUE(notMatches(
2569      "class A { int i; };", fieldDecl(isPublic(), hasName("i"))));
2570  EXPECT_TRUE(notMatches(
2571      "class A { int i; };", fieldDecl(isProtected(), hasName("i"))));
2572  EXPECT_TRUE(matches(
2573      "class A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
2574
2575  EXPECT_TRUE(notMatches(
2576      "class A { protected: int i; };", fieldDecl(isPublic(), hasName("i"))));
2577  EXPECT_TRUE(matches("class A { protected: int i; };",
2578                      fieldDecl(isProtected(), hasName("i"))));
2579  EXPECT_TRUE(notMatches(
2580      "class A { protected: int i; };", fieldDecl(isPrivate(), hasName("i"))));
2581
2582  // Non-member decls have the AccessSpecifier AS_none and thus aren't matched.
2583  EXPECT_TRUE(notMatches("int i;", varDecl(isPublic(), hasName("i"))));
2584  EXPECT_TRUE(notMatches("int i;", varDecl(isProtected(), hasName("i"))));
2585  EXPECT_TRUE(notMatches("int i;", varDecl(isPrivate(), hasName("i"))));
2586}
2587
2588TEST(Member, MatchesMemberAllocationFunction) {
2589  // Fails in C++11 mode
2590  EXPECT_TRUE(matchesConditionally(
2591      "namespace std { typedef typeof(sizeof(int)) size_t; }"
2592      "class X { void *operator new(std::size_t); };",
2593      methodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
2594
2595  EXPECT_TRUE(matches("class X { void operator delete(void*); };",
2596                      methodDecl(ofClass(hasName("X")))));
2597
2598  // Fails in C++11 mode
2599  EXPECT_TRUE(matchesConditionally(
2600      "namespace std { typedef typeof(sizeof(int)) size_t; }"
2601      "class X { void operator delete[](void*, std::size_t); };",
2602      methodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
2603}
2604
2605TEST(HasObjectExpression, DoesNotMatchMember) {
2606  EXPECT_TRUE(notMatches(
2607      "class X {}; struct Z { X m; }; void f(Z z) { z.m; }",
2608      memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
2609}
2610
2611TEST(HasObjectExpression, MatchesBaseOfVariable) {
2612  EXPECT_TRUE(matches(
2613      "struct X { int m; }; void f(X x) { x.m; }",
2614      memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
2615  EXPECT_TRUE(matches(
2616      "struct X { int m; }; void f(X* x) { x->m; }",
2617      memberExpr(hasObjectExpression(
2618          hasType(pointsTo(recordDecl(hasName("X"))))))));
2619}
2620
2621TEST(HasObjectExpression,
2622     MatchesObjectExpressionOfImplicitlyFormedMemberExpression) {
2623  EXPECT_TRUE(matches(
2624      "class X {}; struct S { X m; void f() { this->m; } };",
2625      memberExpr(hasObjectExpression(
2626          hasType(pointsTo(recordDecl(hasName("S"))))))));
2627  EXPECT_TRUE(matches(
2628      "class X {}; struct S { X m; void f() { m; } };",
2629      memberExpr(hasObjectExpression(
2630          hasType(pointsTo(recordDecl(hasName("S"))))))));
2631}
2632
2633TEST(Field, DoesNotMatchNonFieldMembers) {
2634  EXPECT_TRUE(notMatches("class X { void m(); };", fieldDecl(hasName("m"))));
2635  EXPECT_TRUE(notMatches("class X { class m {}; };", fieldDecl(hasName("m"))));
2636  EXPECT_TRUE(notMatches("class X { enum { m }; };", fieldDecl(hasName("m"))));
2637  EXPECT_TRUE(notMatches("class X { enum m {}; };", fieldDecl(hasName("m"))));
2638}
2639
2640TEST(Field, MatchesField) {
2641  EXPECT_TRUE(matches("class X { int m; };", fieldDecl(hasName("m"))));
2642}
2643
2644TEST(IsConstQualified, MatchesConstInt) {
2645  EXPECT_TRUE(matches("const int i = 42;",
2646                      varDecl(hasType(isConstQualified()))));
2647}
2648
2649TEST(IsConstQualified, MatchesConstPointer) {
2650  EXPECT_TRUE(matches("int i = 42; int* const p(&i);",
2651                      varDecl(hasType(isConstQualified()))));
2652}
2653
2654TEST(IsConstQualified, MatchesThroughTypedef) {
2655  EXPECT_TRUE(matches("typedef const int const_int; const_int i = 42;",
2656                      varDecl(hasType(isConstQualified()))));
2657  EXPECT_TRUE(matches("typedef int* int_ptr; const int_ptr p(0);",
2658                      varDecl(hasType(isConstQualified()))));
2659}
2660
2661TEST(IsConstQualified, DoesNotMatchInappropriately) {
2662  EXPECT_TRUE(notMatches("typedef int nonconst_int; nonconst_int i = 42;",
2663                         varDecl(hasType(isConstQualified()))));
2664  EXPECT_TRUE(notMatches("int const* p;",
2665                         varDecl(hasType(isConstQualified()))));
2666}
2667
2668TEST(CastExpression, MatchesExplicitCasts) {
2669  EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
2670  EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
2671  EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
2672  EXPECT_TRUE(matches("char c = char(0);", castExpr()));
2673}
2674TEST(CastExpression, MatchesImplicitCasts) {
2675  // This test creates an implicit cast from int to char.
2676  EXPECT_TRUE(matches("char c = 0;", castExpr()));
2677  // This test creates an implicit cast from lvalue to rvalue.
2678  EXPECT_TRUE(matches("char c = 0, d = c;", castExpr()));
2679}
2680
2681TEST(CastExpression, DoesNotMatchNonCasts) {
2682  EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
2683  EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
2684  EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
2685  EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
2686}
2687
2688TEST(ReinterpretCast, MatchesSimpleCase) {
2689  EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
2690                      reinterpretCastExpr()));
2691}
2692
2693TEST(ReinterpretCast, DoesNotMatchOtherCasts) {
2694  EXPECT_TRUE(notMatches("char* p = (char*)(&p);", reinterpretCastExpr()));
2695  EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
2696                         reinterpretCastExpr()));
2697  EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
2698                         reinterpretCastExpr()));
2699  EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
2700                         "B b;"
2701                         "D* p = dynamic_cast<D*>(&b);",
2702                         reinterpretCastExpr()));
2703}
2704
2705TEST(FunctionalCast, MatchesSimpleCase) {
2706  std::string foo_class = "class Foo { public: Foo(const char*); };";
2707  EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
2708                      functionalCastExpr()));
2709}
2710
2711TEST(FunctionalCast, DoesNotMatchOtherCasts) {
2712  std::string FooClass = "class Foo { public: Foo(const char*); };";
2713  EXPECT_TRUE(
2714      notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
2715                 functionalCastExpr()));
2716  EXPECT_TRUE(
2717      notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
2718                 functionalCastExpr()));
2719}
2720
2721TEST(DynamicCast, MatchesSimpleCase) {
2722  EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
2723                      "B b;"
2724                      "D* p = dynamic_cast<D*>(&b);",
2725                      dynamicCastExpr()));
2726}
2727
2728TEST(StaticCast, MatchesSimpleCase) {
2729  EXPECT_TRUE(matches("void* p(static_cast<void*>(&p));",
2730                      staticCastExpr()));
2731}
2732
2733TEST(StaticCast, DoesNotMatchOtherCasts) {
2734  EXPECT_TRUE(notMatches("char* p = (char*)(&p);", staticCastExpr()));
2735  EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
2736                         staticCastExpr()));
2737  EXPECT_TRUE(notMatches("void* p = reinterpret_cast<char*>(&p);",
2738                         staticCastExpr()));
2739  EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
2740                         "B b;"
2741                         "D* p = dynamic_cast<D*>(&b);",
2742                         staticCastExpr()));
2743}
2744
2745TEST(CStyleCast, MatchesSimpleCase) {
2746  EXPECT_TRUE(matches("int i = (int) 2.2f;", cStyleCastExpr()));
2747}
2748
2749TEST(CStyleCast, DoesNotMatchOtherCasts) {
2750  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
2751                         "char q, *r = const_cast<char*>(&q);"
2752                         "void* s = reinterpret_cast<char*>(&s);"
2753                         "struct B { virtual ~B() {} }; struct D : B {};"
2754                         "B b;"
2755                         "D* t = dynamic_cast<D*>(&b);",
2756                         cStyleCastExpr()));
2757}
2758
2759TEST(HasDestinationType, MatchesSimpleCase) {
2760  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
2761                      staticCastExpr(hasDestinationType(
2762                          pointsTo(TypeMatcher(anything()))))));
2763}
2764
2765TEST(HasImplicitDestinationType, MatchesSimpleCase) {
2766  // This test creates an implicit const cast.
2767  EXPECT_TRUE(matches("int x; const int i = x;",
2768                      implicitCastExpr(
2769                          hasImplicitDestinationType(isInteger()))));
2770  // This test creates an implicit array-to-pointer cast.
2771  EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
2772                      implicitCastExpr(hasImplicitDestinationType(
2773                          pointsTo(TypeMatcher(anything()))))));
2774}
2775
2776TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
2777  // This test creates an implicit cast from int to char.
2778  EXPECT_TRUE(notMatches("char c = 0;",
2779                      implicitCastExpr(hasImplicitDestinationType(
2780                          unless(anything())))));
2781  // This test creates an implicit array-to-pointer cast.
2782  EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
2783                      implicitCastExpr(hasImplicitDestinationType(
2784                          unless(anything())))));
2785}
2786
2787TEST(ImplicitCast, MatchesSimpleCase) {
2788  // This test creates an implicit const cast.
2789  EXPECT_TRUE(matches("int x = 0; const int y = x;",
2790                      varDecl(hasInitializer(implicitCastExpr()))));
2791  // This test creates an implicit cast from int to char.
2792  EXPECT_TRUE(matches("char c = 0;",
2793                      varDecl(hasInitializer(implicitCastExpr()))));
2794  // This test creates an implicit array-to-pointer cast.
2795  EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
2796                      varDecl(hasInitializer(implicitCastExpr()))));
2797}
2798
2799TEST(ImplicitCast, DoesNotMatchIncorrectly) {
2800  // This test verifies that implicitCastExpr() matches exactly when implicit casts
2801  // are present, and that it ignores explicit and paren casts.
2802
2803  // These two test cases have no casts.
2804  EXPECT_TRUE(notMatches("int x = 0;",
2805                         varDecl(hasInitializer(implicitCastExpr()))));
2806  EXPECT_TRUE(notMatches("int x = 0, &y = x;",
2807                         varDecl(hasInitializer(implicitCastExpr()))));
2808
2809  EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;",
2810                         varDecl(hasInitializer(implicitCastExpr()))));
2811  EXPECT_TRUE(notMatches("const int *p; int *q = const_cast<int *>(p);",
2812                         varDecl(hasInitializer(implicitCastExpr()))));
2813
2814  EXPECT_TRUE(notMatches("int x = (0);",
2815                         varDecl(hasInitializer(implicitCastExpr()))));
2816}
2817
2818TEST(IgnoringImpCasts, MatchesImpCasts) {
2819  // This test checks that ignoringImpCasts matches when implicit casts are
2820  // present and its inner matcher alone does not match.
2821  // Note that this test creates an implicit const cast.
2822  EXPECT_TRUE(matches("int x = 0; const int y = x;",
2823                      varDecl(hasInitializer(ignoringImpCasts(
2824                          declRefExpr(to(varDecl(hasName("x")))))))));
2825  // This test creates an implict cast from int to char.
2826  EXPECT_TRUE(matches("char x = 0;",
2827                      varDecl(hasInitializer(ignoringImpCasts(
2828                          integerLiteral(equals(0)))))));
2829}
2830
2831TEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
2832  // These tests verify that ignoringImpCasts does not match if the inner
2833  // matcher does not match.
2834  // Note that the first test creates an implicit const cast.
2835  EXPECT_TRUE(notMatches("int x; const int y = x;",
2836                         varDecl(hasInitializer(ignoringImpCasts(
2837                             unless(anything()))))));
2838  EXPECT_TRUE(notMatches("int x; int y = x;",
2839                         varDecl(hasInitializer(ignoringImpCasts(
2840                             unless(anything()))))));
2841
2842  // These tests verify that ignoringImplictCasts does not look through explicit
2843  // casts or parentheses.
2844  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
2845                         varDecl(hasInitializer(ignoringImpCasts(
2846                             integerLiteral())))));
2847  EXPECT_TRUE(notMatches("int i = (0);",
2848                         varDecl(hasInitializer(ignoringImpCasts(
2849                             integerLiteral())))));
2850  EXPECT_TRUE(notMatches("float i = (float)0;",
2851                         varDecl(hasInitializer(ignoringImpCasts(
2852                             integerLiteral())))));
2853  EXPECT_TRUE(notMatches("float i = float(0);",
2854                         varDecl(hasInitializer(ignoringImpCasts(
2855                             integerLiteral())))));
2856}
2857
2858TEST(IgnoringImpCasts, MatchesWithoutImpCasts) {
2859  // This test verifies that expressions that do not have implicit casts
2860  // still match the inner matcher.
2861  EXPECT_TRUE(matches("int x = 0; int &y = x;",
2862                      varDecl(hasInitializer(ignoringImpCasts(
2863                          declRefExpr(to(varDecl(hasName("x")))))))));
2864}
2865
2866TEST(IgnoringParenCasts, MatchesParenCasts) {
2867  // This test checks that ignoringParenCasts matches when parentheses and/or
2868  // casts are present and its inner matcher alone does not match.
2869  EXPECT_TRUE(matches("int x = (0);",
2870                      varDecl(hasInitializer(ignoringParenCasts(
2871                          integerLiteral(equals(0)))))));
2872  EXPECT_TRUE(matches("int x = (((((0)))));",
2873                      varDecl(hasInitializer(ignoringParenCasts(
2874                          integerLiteral(equals(0)))))));
2875
2876  // This test creates an implict cast from int to char in addition to the
2877  // parentheses.
2878  EXPECT_TRUE(matches("char x = (0);",
2879                      varDecl(hasInitializer(ignoringParenCasts(
2880                          integerLiteral(equals(0)))))));
2881
2882  EXPECT_TRUE(matches("char x = (char)0;",
2883                      varDecl(hasInitializer(ignoringParenCasts(
2884                          integerLiteral(equals(0)))))));
2885  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
2886                      varDecl(hasInitializer(ignoringParenCasts(
2887                          integerLiteral(equals(0)))))));
2888}
2889
2890TEST(IgnoringParenCasts, MatchesWithoutParenCasts) {
2891  // This test verifies that expressions that do not have any casts still match.
2892  EXPECT_TRUE(matches("int x = 0;",
2893                      varDecl(hasInitializer(ignoringParenCasts(
2894                          integerLiteral(equals(0)))))));
2895}
2896
2897TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) {
2898  // These tests verify that ignoringImpCasts does not match if the inner
2899  // matcher does not match.
2900  EXPECT_TRUE(notMatches("int x = ((0));",
2901                         varDecl(hasInitializer(ignoringParenCasts(
2902                             unless(anything()))))));
2903
2904  // This test creates an implicit cast from int to char in addition to the
2905  // parentheses.
2906  EXPECT_TRUE(notMatches("char x = ((0));",
2907                         varDecl(hasInitializer(ignoringParenCasts(
2908                             unless(anything()))))));
2909
2910  EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
2911                         varDecl(hasInitializer(ignoringParenCasts(
2912                             unless(anything()))))));
2913}
2914
2915TEST(IgnoringParenAndImpCasts, MatchesParenImpCasts) {
2916  // This test checks that ignoringParenAndImpCasts matches when
2917  // parentheses and/or implicit casts are present and its inner matcher alone
2918  // does not match.
2919  // Note that this test creates an implicit const cast.
2920  EXPECT_TRUE(matches("int x = 0; const int y = x;",
2921                      varDecl(hasInitializer(ignoringParenImpCasts(
2922                          declRefExpr(to(varDecl(hasName("x")))))))));
2923  // This test creates an implicit cast from int to char.
2924  EXPECT_TRUE(matches("const char x = (0);",
2925                      varDecl(hasInitializer(ignoringParenImpCasts(
2926                          integerLiteral(equals(0)))))));
2927}
2928
2929TEST(IgnoringParenAndImpCasts, MatchesWithoutParenImpCasts) {
2930  // This test verifies that expressions that do not have parentheses or
2931  // implicit casts still match.
2932  EXPECT_TRUE(matches("int x = 0; int &y = x;",
2933                      varDecl(hasInitializer(ignoringParenImpCasts(
2934                          declRefExpr(to(varDecl(hasName("x")))))))));
2935  EXPECT_TRUE(matches("int x = 0;",
2936                      varDecl(hasInitializer(ignoringParenImpCasts(
2937                          integerLiteral(equals(0)))))));
2938}
2939
2940TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) {
2941  // These tests verify that ignoringParenImpCasts does not match if
2942  // the inner matcher does not match.
2943  // This test creates an implicit cast.
2944  EXPECT_TRUE(notMatches("char c = ((3));",
2945                         varDecl(hasInitializer(ignoringParenImpCasts(
2946                             unless(anything()))))));
2947  // These tests verify that ignoringParenAndImplictCasts does not look
2948  // through explicit casts.
2949  EXPECT_TRUE(notMatches("float y = (float(0));",
2950                         varDecl(hasInitializer(ignoringParenImpCasts(
2951                             integerLiteral())))));
2952  EXPECT_TRUE(notMatches("float y = (float)0;",
2953                         varDecl(hasInitializer(ignoringParenImpCasts(
2954                             integerLiteral())))));
2955  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
2956                         varDecl(hasInitializer(ignoringParenImpCasts(
2957                             integerLiteral())))));
2958}
2959
2960TEST(HasSourceExpression, MatchesImplicitCasts) {
2961  EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
2962                      "void r() {string a_string; URL url = a_string; }",
2963                      implicitCastExpr(
2964                          hasSourceExpression(constructExpr()))));
2965}
2966
2967TEST(HasSourceExpression, MatchesExplicitCasts) {
2968  EXPECT_TRUE(matches("float x = static_cast<float>(42);",
2969                      explicitCastExpr(
2970                          hasSourceExpression(hasDescendant(
2971                              expr(integerLiteral()))))));
2972}
2973
2974TEST(Statement, DoesNotMatchDeclarations) {
2975  EXPECT_TRUE(notMatches("class X {};", stmt()));
2976}
2977
2978TEST(Statement, MatchesCompoundStatments) {
2979  EXPECT_TRUE(matches("void x() {}", stmt()));
2980}
2981
2982TEST(DeclarationStatement, DoesNotMatchCompoundStatements) {
2983  EXPECT_TRUE(notMatches("void x() {}", declStmt()));
2984}
2985
2986TEST(DeclarationStatement, MatchesVariableDeclarationStatements) {
2987  EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
2988}
2989
2990TEST(ExprWithCleanups, MatchesExprWithCleanups) {
2991  EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
2992                      "const Foo f = Foo();",
2993                      varDecl(hasInitializer(exprWithCleanups()))));
2994  EXPECT_FALSE(matches("struct Foo { };"
2995                      "const Foo f = Foo();",
2996                      varDecl(hasInitializer(exprWithCleanups()))));
2997}
2998
2999TEST(InitListExpression, MatchesInitListExpression) {
3000  EXPECT_TRUE(matches("int a[] = { 1, 2 };",
3001                      initListExpr(hasType(asString("int [2]")))));
3002  EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
3003                      initListExpr(hasType(recordDecl(hasName("B"))))));
3004}
3005
3006TEST(UsingDeclaration, MatchesUsingDeclarations) {
3007  EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
3008                      usingDecl()));
3009}
3010
3011TEST(UsingDeclaration, MatchesShadowUsingDelcarations) {
3012  EXPECT_TRUE(matches("namespace f { int a; } using f::a;",
3013                      usingDecl(hasAnyUsingShadowDecl(hasName("a")))));
3014}
3015
3016TEST(UsingDeclaration, MatchesSpecificTarget) {
3017  EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
3018                      usingDecl(hasAnyUsingShadowDecl(
3019                          hasTargetDecl(functionDecl())))));
3020  EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
3021                         usingDecl(hasAnyUsingShadowDecl(
3022                             hasTargetDecl(functionDecl())))));
3023}
3024
3025TEST(UsingDeclaration, ThroughUsingDeclaration) {
3026  EXPECT_TRUE(matches(
3027      "namespace a { void f(); } using a::f; void g() { f(); }",
3028      declRefExpr(throughUsingDecl(anything()))));
3029  EXPECT_TRUE(notMatches(
3030      "namespace a { void f(); } using a::f; void g() { a::f(); }",
3031      declRefExpr(throughUsingDecl(anything()))));
3032}
3033
3034TEST(SingleDecl, IsSingleDecl) {
3035  StatementMatcher SingleDeclStmt =
3036      declStmt(hasSingleDecl(varDecl(hasInitializer(anything()))));
3037  EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
3038  EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
3039  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
3040                          SingleDeclStmt));
3041}
3042
3043TEST(DeclStmt, ContainsDeclaration) {
3044  DeclarationMatcher MatchesInit = varDecl(hasInitializer(anything()));
3045
3046  EXPECT_TRUE(matches("void f() {int a = 4;}",
3047                      declStmt(containsDeclaration(0, MatchesInit))));
3048  EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
3049                      declStmt(containsDeclaration(0, MatchesInit),
3050                               containsDeclaration(1, MatchesInit))));
3051  unsigned WrongIndex = 42;
3052  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
3053                         declStmt(containsDeclaration(WrongIndex,
3054                                                      MatchesInit))));
3055}
3056
3057TEST(DeclCount, DeclCountIsCorrect) {
3058  EXPECT_TRUE(matches("void f() {int i,j;}",
3059                      declStmt(declCountIs(2))));
3060  EXPECT_TRUE(notMatches("void f() {int i,j; int k;}",
3061                         declStmt(declCountIs(3))));
3062  EXPECT_TRUE(notMatches("void f() {int i,j, k, l;}",
3063                         declStmt(declCountIs(3))));
3064}
3065
3066TEST(While, MatchesWhileLoops) {
3067  EXPECT_TRUE(notMatches("void x() {}", whileStmt()));
3068  EXPECT_TRUE(matches("void x() { while(true); }", whileStmt()));
3069  EXPECT_TRUE(notMatches("void x() { do {} while(true); }", whileStmt()));
3070}
3071
3072TEST(Do, MatchesDoLoops) {
3073  EXPECT_TRUE(matches("void x() { do {} while(true); }", doStmt()));
3074  EXPECT_TRUE(matches("void x() { do ; while(false); }", doStmt()));
3075}
3076
3077TEST(Do, DoesNotMatchWhileLoops) {
3078  EXPECT_TRUE(notMatches("void x() { while(true) {} }", doStmt()));
3079}
3080
3081TEST(SwitchCase, MatchesCase) {
3082  EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchCase()));
3083  EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchCase()));
3084  EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchCase()));
3085  EXPECT_TRUE(notMatches("void x() { switch(42) {} }", switchCase()));
3086}
3087
3088TEST(SwitchCase, MatchesSwitch) {
3089  EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchStmt()));
3090  EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchStmt()));
3091  EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchStmt()));
3092  EXPECT_TRUE(notMatches("void x() {}", switchStmt()));
3093}
3094
3095TEST(SwitchCase, MatchesEachCase) {
3096  EXPECT_TRUE(notMatches("void x() { switch(42); }",
3097                         switchStmt(forEachSwitchCase(caseStmt()))));
3098  EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
3099                      switchStmt(forEachSwitchCase(caseStmt()))));
3100  EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
3101                      switchStmt(forEachSwitchCase(caseStmt()))));
3102  EXPECT_TRUE(notMatches(
3103      "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
3104      ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
3105  EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
3106                      switchStmt(forEachSwitchCase(
3107                          caseStmt(hasCaseConstant(integerLiteral()))))));
3108  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
3109                         switchStmt(forEachSwitchCase(
3110                             caseStmt(hasCaseConstant(integerLiteral()))))));
3111  EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
3112                         switchStmt(forEachSwitchCase(
3113                             caseStmt(hasCaseConstant(integerLiteral()))))));
3114  EXPECT_TRUE(matchAndVerifyResultTrue(
3115      "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
3116      switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
3117      new VerifyIdIsBoundTo<CaseStmt>("x", 3)));
3118}
3119
3120TEST(ForEachConstructorInitializer, MatchesInitializers) {
3121  EXPECT_TRUE(matches(
3122      "struct X { X() : i(42), j(42) {} int i, j; };",
3123      constructorDecl(forEachConstructorInitializer(ctorInitializer()))));
3124}
3125
3126TEST(ExceptionHandling, SimpleCases) {
3127  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", catchStmt()));
3128  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", tryStmt()));
3129  EXPECT_TRUE(notMatches("void foo() try { } catch(int X) { }", throwExpr()));
3130  EXPECT_TRUE(matches("void foo() try { throw; } catch(int X) { }",
3131                      throwExpr()));
3132  EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }",
3133                      throwExpr()));
3134}
3135
3136TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
3137  EXPECT_TRUE(notMatches(
3138      "void x() { if(true) {} }",
3139      ifStmt(hasConditionVariableStatement(declStmt()))));
3140  EXPECT_TRUE(notMatches(
3141      "void x() { int x; if((x = 42)) {} }",
3142      ifStmt(hasConditionVariableStatement(declStmt()))));
3143}
3144
3145TEST(HasConditionVariableStatement, MatchesConditionVariables) {
3146  EXPECT_TRUE(matches(
3147      "void x() { if(int* a = 0) {} }",
3148      ifStmt(hasConditionVariableStatement(declStmt()))));
3149}
3150
3151TEST(ForEach, BindsOneNode) {
3152  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
3153      recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
3154      new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
3155}
3156
3157TEST(ForEach, BindsMultipleNodes) {
3158  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
3159      recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
3160      new VerifyIdIsBoundTo<FieldDecl>("f", 3)));
3161}
3162
3163TEST(ForEach, BindsRecursiveCombinations) {
3164  EXPECT_TRUE(matchAndVerifyResultTrue(
3165      "class C { class D { int x; int y; }; class E { int y; int z; }; };",
3166      recordDecl(hasName("C"),
3167                 forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
3168      new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
3169}
3170
3171TEST(ForEachDescendant, BindsOneNode) {
3172  EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
3173      recordDecl(hasName("C"),
3174                 forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
3175      new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
3176}
3177
3178TEST(ForEachDescendant, NestedForEachDescendant) {
3179  DeclarationMatcher m = recordDecl(
3180      isDefinition(), decl().bind("x"), hasName("C"));
3181  EXPECT_TRUE(matchAndVerifyResultTrue(
3182    "class A { class B { class C {}; }; };",
3183    recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
3184    new VerifyIdIsBoundTo<Decl>("x", "C")));
3185
3186  // Check that a partial match of 'm' that binds 'x' in the
3187  // first part of anyOf(m, anything()) will not overwrite the
3188  // binding created by the earlier binding in the hasDescendant.
3189  EXPECT_TRUE(matchAndVerifyResultTrue(
3190      "class A { class B { class C {}; }; };",
3191      recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
3192      new VerifyIdIsBoundTo<Decl>("x", "C")));
3193}
3194
3195TEST(ForEachDescendant, BindsMultipleNodes) {
3196  EXPECT_TRUE(matchAndVerifyResultTrue(
3197      "class C { class D { int x; int y; }; "
3198      "          class E { class F { int y; int z; }; }; };",
3199      recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
3200      new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
3201}
3202
3203TEST(ForEachDescendant, BindsRecursiveCombinations) {
3204  EXPECT_TRUE(matchAndVerifyResultTrue(
3205      "class C { class D { "
3206      "          class E { class F { class G { int y; int z; }; }; }; }; };",
3207      recordDecl(hasName("C"), forEachDescendant(recordDecl(
3208          forEachDescendant(fieldDecl().bind("f"))))),
3209      new VerifyIdIsBoundTo<FieldDecl>("f", 8)));
3210}
3211
3212TEST(ForEachDescendant, BindsCombinations) {
3213  EXPECT_TRUE(matchAndVerifyResultTrue(
3214      "void f() { if(true) {} if (true) {} while (true) {} if (true) {} while "
3215      "(true) {} }",
3216      compoundStmt(forEachDescendant(ifStmt().bind("if")),
3217                   forEachDescendant(whileStmt().bind("while"))),
3218      new VerifyIdIsBoundTo<IfStmt>("if", 6)));
3219}
3220
3221TEST(Has, DoesNotDeleteBindings) {
3222  EXPECT_TRUE(matchAndVerifyResultTrue(
3223      "class X { int a; };", recordDecl(decl().bind("x"), has(fieldDecl())),
3224      new VerifyIdIsBoundTo<Decl>("x", 1)));
3225}
3226
3227TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
3228  // Those matchers cover all the cases where an inner matcher is called
3229  // and there is not a 1:1 relationship between the match of the outer
3230  // matcher and the match of the inner matcher.
3231  // The pattern to look for is:
3232  //   ... return InnerMatcher.matches(...); ...
3233  // In which case no special handling is needed.
3234  //
3235  // On the other hand, if there are multiple alternative matches
3236  // (for example forEach*) or matches might be discarded (for example has*)
3237  // the implementation must make sure that the discarded matches do not
3238  // affect the bindings.
3239  // When new such matchers are added, add a test here that:
3240  // - matches a simple node, and binds it as the first thing in the matcher:
3241  //     recordDecl(decl().bind("x"), hasName("X")))
3242  // - uses the matcher under test afterwards in a way that not the first
3243  //   alternative is matched; for anyOf, that means the first branch
3244  //   would need to return false; for hasAncestor, it means that not
3245  //   the direct parent matches the inner matcher.
3246
3247  EXPECT_TRUE(matchAndVerifyResultTrue(
3248      "class X { int y; };",
3249      recordDecl(
3250          recordDecl().bind("x"), hasName("::X"),
3251          anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
3252      new VerifyIdIsBoundTo<CXXRecordDecl>("x", 1)));
3253  EXPECT_TRUE(matchAndVerifyResultTrue(
3254      "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
3255                                anyOf(unless(anything()), anything())),
3256      new VerifyIdIsBoundTo<CXXRecordDecl>("x", 1)));
3257  EXPECT_TRUE(matchAndVerifyResultTrue(
3258      "template<typename T1, typename T2> class X {}; X<float, int> x;",
3259      classTemplateSpecializationDecl(
3260          decl().bind("x"),
3261          hasAnyTemplateArgument(refersToType(asString("int")))),
3262      new VerifyIdIsBoundTo<Decl>("x", 1)));
3263  EXPECT_TRUE(matchAndVerifyResultTrue(
3264      "class X { void f(); void g(); };",
3265      recordDecl(decl().bind("x"), hasMethod(hasName("g"))),
3266      new VerifyIdIsBoundTo<Decl>("x", 1)));
3267  EXPECT_TRUE(matchAndVerifyResultTrue(
3268      "class X { X() : a(1), b(2) {} double a; int b; };",
3269      recordDecl(decl().bind("x"),
3270                 has(constructorDecl(
3271                     hasAnyConstructorInitializer(forField(hasName("b")))))),
3272      new VerifyIdIsBoundTo<Decl>("x", 1)));
3273  EXPECT_TRUE(matchAndVerifyResultTrue(
3274      "void x(int, int) { x(0, 42); }",
3275      callExpr(expr().bind("x"), hasAnyArgument(integerLiteral(equals(42)))),
3276      new VerifyIdIsBoundTo<Expr>("x", 1)));
3277  EXPECT_TRUE(matchAndVerifyResultTrue(
3278      "void x(int, int y) {}",
3279      functionDecl(decl().bind("x"), hasAnyParameter(hasName("y"))),
3280      new VerifyIdIsBoundTo<Decl>("x", 1)));
3281  EXPECT_TRUE(matchAndVerifyResultTrue(
3282      "void x() { return; if (true) {} }",
3283      functionDecl(decl().bind("x"),
3284                   has(compoundStmt(hasAnySubstatement(ifStmt())))),
3285      new VerifyIdIsBoundTo<Decl>("x", 1)));
3286  EXPECT_TRUE(matchAndVerifyResultTrue(
3287      "namespace X { void b(int); void b(); }"
3288      "using X::b;",
3289      usingDecl(decl().bind("x"), hasAnyUsingShadowDecl(hasTargetDecl(
3290                                      functionDecl(parameterCountIs(1))))),
3291      new VerifyIdIsBoundTo<Decl>("x", 1)));
3292  EXPECT_TRUE(matchAndVerifyResultTrue(
3293      "class A{}; class B{}; class C : B, A {};",
3294      recordDecl(decl().bind("x"), isDerivedFrom("::A")),
3295      new VerifyIdIsBoundTo<Decl>("x", 1)));
3296  EXPECT_TRUE(matchAndVerifyResultTrue(
3297      "class A{}; typedef A B; typedef A C; typedef A D;"
3298      "class E : A {};",
3299      recordDecl(decl().bind("x"), isDerivedFrom("C")),
3300      new VerifyIdIsBoundTo<Decl>("x", 1)));
3301  EXPECT_TRUE(matchAndVerifyResultTrue(
3302      "class A { class B { void f() {} }; };",
3303      functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
3304      new VerifyIdIsBoundTo<Decl>("x", 1)));
3305  EXPECT_TRUE(matchAndVerifyResultTrue(
3306      "template <typename T> struct A { struct B {"
3307      "  void f() { if(true) {} }"
3308      "}; };"
3309      "void t() { A<int>::B b; b.f(); }",
3310      ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
3311      new VerifyIdIsBoundTo<Stmt>("x", 2)));
3312  EXPECT_TRUE(matchAndVerifyResultTrue(
3313      "class A {};",
3314      recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
3315      new VerifyIdIsBoundTo<Decl>("x", 1)));
3316  EXPECT_TRUE(matchAndVerifyResultTrue(
3317      "class A { A() : s(), i(42) {} const char *s; int i; };",
3318      constructorDecl(hasName("::A::A"), decl().bind("x"),
3319                      forEachConstructorInitializer(forField(hasName("i")))),
3320      new VerifyIdIsBoundTo<Decl>("x", 1)));
3321}
3322
3323TEST(ForEachDescendant, BindsCorrectNodes) {
3324  EXPECT_TRUE(matchAndVerifyResultTrue(
3325      "class C { void f(); int i; };",
3326      recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
3327      new VerifyIdIsBoundTo<FieldDecl>("decl", 1)));
3328  EXPECT_TRUE(matchAndVerifyResultTrue(
3329      "class C { void f() {} int i; };",
3330      recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
3331      new VerifyIdIsBoundTo<FunctionDecl>("decl", 1)));
3332}
3333
3334TEST(FindAll, BindsNodeOnMatch) {
3335  EXPECT_TRUE(matchAndVerifyResultTrue(
3336      "class A {};",
3337      recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
3338      new VerifyIdIsBoundTo<CXXRecordDecl>("v", 1)));
3339}
3340
3341TEST(FindAll, BindsDescendantNodeOnMatch) {
3342  EXPECT_TRUE(matchAndVerifyResultTrue(
3343      "class A { int a; int b; };",
3344      recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
3345      new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
3346}
3347
3348TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
3349  EXPECT_TRUE(matchAndVerifyResultTrue(
3350      "class A { int a; int b; };",
3351      recordDecl(hasName("::A"),
3352                 findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
3353                                    fieldDecl().bind("v"))))),
3354      new VerifyIdIsBoundTo<Decl>("v", 3)));
3355
3356  EXPECT_TRUE(matchAndVerifyResultTrue(
3357      "class A { class B {}; class C {}; };",
3358      recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
3359      new VerifyIdIsBoundTo<CXXRecordDecl>("v", 3)));
3360}
3361
3362TEST(EachOf, TriggersForEachMatch) {
3363  EXPECT_TRUE(matchAndVerifyResultTrue(
3364      "class A { int a; int b; };",
3365      recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3366                        has(fieldDecl(hasName("b")).bind("v")))),
3367      new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
3368}
3369
3370TEST(EachOf, BehavesLikeAnyOfUnlessBothMatch) {
3371  EXPECT_TRUE(matchAndVerifyResultTrue(
3372      "class A { int a; int c; };",
3373      recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3374                        has(fieldDecl(hasName("b")).bind("v")))),
3375      new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
3376  EXPECT_TRUE(matchAndVerifyResultTrue(
3377      "class A { int c; int b; };",
3378      recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3379                        has(fieldDecl(hasName("b")).bind("v")))),
3380      new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
3381  EXPECT_TRUE(notMatches(
3382      "class A { int c; int d; };",
3383      recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
3384                        has(fieldDecl(hasName("b")).bind("v"))))));
3385}
3386
3387TEST(IsTemplateInstantiation, MatchesImplicitClassTemplateInstantiation) {
3388  // Make sure that we can both match the class by name (::X) and by the type
3389  // the template was instantiated with (via a field).
3390
3391  EXPECT_TRUE(matches(
3392      "template <typename T> class X {}; class A {}; X<A> x;",
3393      recordDecl(hasName("::X"), isTemplateInstantiation())));
3394
3395  EXPECT_TRUE(matches(
3396      "template <typename T> class X { T t; }; class A {}; X<A> x;",
3397      recordDecl(isTemplateInstantiation(), hasDescendant(
3398          fieldDecl(hasType(recordDecl(hasName("A"))))))));
3399}
3400
3401TEST(IsTemplateInstantiation, MatchesImplicitFunctionTemplateInstantiation) {
3402  EXPECT_TRUE(matches(
3403      "template <typename T> void f(T t) {} class A {}; void g() { f(A()); }",
3404      functionDecl(hasParameter(0, hasType(recordDecl(hasName("A")))),
3405               isTemplateInstantiation())));
3406}
3407
3408TEST(IsTemplateInstantiation, MatchesExplicitClassTemplateInstantiation) {
3409  EXPECT_TRUE(matches(
3410      "template <typename T> class X { T t; }; class A {};"
3411      "template class X<A>;",
3412      recordDecl(isTemplateInstantiation(), hasDescendant(
3413          fieldDecl(hasType(recordDecl(hasName("A"))))))));
3414}
3415
3416TEST(IsTemplateInstantiation,
3417     MatchesInstantiationOfPartiallySpecializedClassTemplate) {
3418  EXPECT_TRUE(matches(
3419      "template <typename T> class X {};"
3420      "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
3421      recordDecl(hasName("::X"), isTemplateInstantiation())));
3422}
3423
3424TEST(IsTemplateInstantiation,
3425     MatchesInstantiationOfClassTemplateNestedInNonTemplate) {
3426  EXPECT_TRUE(matches(
3427      "class A {};"
3428      "class X {"
3429      "  template <typename U> class Y { U u; };"
3430      "  Y<A> y;"
3431      "};",
3432      recordDecl(hasName("::X::Y"), isTemplateInstantiation())));
3433}
3434
3435TEST(IsTemplateInstantiation, DoesNotMatchInstantiationsInsideOfInstantiation) {
3436  // FIXME: Figure out whether this makes sense. It doesn't affect the
3437  // normal use case as long as the uppermost instantiation always is marked
3438  // as template instantiation, but it might be confusing as a predicate.
3439  EXPECT_TRUE(matches(
3440      "class A {};"
3441      "template <typename T> class X {"
3442      "  template <typename U> class Y { U u; };"
3443      "  Y<T> y;"
3444      "}; X<A> x;",
3445      recordDecl(hasName("::X<A>::Y"), unless(isTemplateInstantiation()))));
3446}
3447
3448TEST(IsTemplateInstantiation, DoesNotMatchExplicitClassTemplateSpecialization) {
3449  EXPECT_TRUE(notMatches(
3450      "template <typename T> class X {}; class A {};"
3451      "template <> class X<A> {}; X<A> x;",
3452      recordDecl(hasName("::X"), isTemplateInstantiation())));
3453}
3454
3455TEST(IsTemplateInstantiation, DoesNotMatchNonTemplate) {
3456  EXPECT_TRUE(notMatches(
3457      "class A {}; class Y { A a; };",
3458      recordDecl(isTemplateInstantiation())));
3459}
3460
3461TEST(IsExplicitTemplateSpecialization,
3462     DoesNotMatchPrimaryTemplate) {
3463  EXPECT_TRUE(notMatches(
3464      "template <typename T> class X {};",
3465      recordDecl(isExplicitTemplateSpecialization())));
3466  EXPECT_TRUE(notMatches(
3467      "template <typename T> void f(T t);",
3468      functionDecl(isExplicitTemplateSpecialization())));
3469}
3470
3471TEST(IsExplicitTemplateSpecialization,
3472     DoesNotMatchExplicitTemplateInstantiations) {
3473  EXPECT_TRUE(notMatches(
3474      "template <typename T> class X {};"
3475      "template class X<int>; extern template class X<long>;",
3476      recordDecl(isExplicitTemplateSpecialization())));
3477  EXPECT_TRUE(notMatches(
3478      "template <typename T> void f(T t) {}"
3479      "template void f(int t); extern template void f(long t);",
3480      functionDecl(isExplicitTemplateSpecialization())));
3481}
3482
3483TEST(IsExplicitTemplateSpecialization,
3484     DoesNotMatchImplicitTemplateInstantiations) {
3485  EXPECT_TRUE(notMatches(
3486      "template <typename T> class X {}; X<int> x;",
3487      recordDecl(isExplicitTemplateSpecialization())));
3488  EXPECT_TRUE(notMatches(
3489      "template <typename T> void f(T t); void g() { f(10); }",
3490      functionDecl(isExplicitTemplateSpecialization())));
3491}
3492
3493TEST(IsExplicitTemplateSpecialization,
3494     MatchesExplicitTemplateSpecializations) {
3495  EXPECT_TRUE(matches(
3496      "template <typename T> class X {};"
3497      "template<> class X<int> {};",
3498      recordDecl(isExplicitTemplateSpecialization())));
3499  EXPECT_TRUE(matches(
3500      "template <typename T> void f(T t) {}"
3501      "template<> void f(int t) {}",
3502      functionDecl(isExplicitTemplateSpecialization())));
3503}
3504
3505TEST(HasAncenstor, MatchesDeclarationAncestors) {
3506  EXPECT_TRUE(matches(
3507      "class A { class B { class C {}; }; };",
3508      recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("A"))))));
3509}
3510
3511TEST(HasAncenstor, FailsIfNoAncestorMatches) {
3512  EXPECT_TRUE(notMatches(
3513      "class A { class B { class C {}; }; };",
3514      recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("X"))))));
3515}
3516
3517TEST(HasAncestor, MatchesDeclarationsThatGetVisitedLater) {
3518  EXPECT_TRUE(matches(
3519      "class A { class B { void f() { C c; } class C {}; }; };",
3520      varDecl(hasName("c"), hasType(recordDecl(hasName("C"),
3521          hasAncestor(recordDecl(hasName("A"))))))));
3522}
3523
3524TEST(HasAncenstor, MatchesStatementAncestors) {
3525  EXPECT_TRUE(matches(
3526      "void f() { if (true) { while (false) { 42; } } }",
3527      integerLiteral(equals(42), hasAncestor(ifStmt()))));
3528}
3529
3530TEST(HasAncestor, DrillsThroughDifferentHierarchies) {
3531  EXPECT_TRUE(matches(
3532      "void f() { if (true) { int x = 42; } }",
3533      integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
3534}
3535
3536TEST(HasAncestor, BindsRecursiveCombinations) {
3537  EXPECT_TRUE(matchAndVerifyResultTrue(
3538      "class C { class D { class E { class F { int y; }; }; }; };",
3539      fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
3540      new VerifyIdIsBoundTo<CXXRecordDecl>("r", 1)));
3541}
3542
3543TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
3544  EXPECT_TRUE(matchAndVerifyResultTrue(
3545      "class C { class D { class E { class F { int y; }; }; }; };",
3546      fieldDecl(hasAncestor(
3547          decl(
3548            hasDescendant(recordDecl(isDefinition(),
3549                                     hasAncestor(recordDecl())))
3550          ).bind("d")
3551      )),
3552      new VerifyIdIsBoundTo<CXXRecordDecl>("d", "E")));
3553}
3554
3555TEST(HasAncestor, MatchesClosestAncestor) {
3556  EXPECT_TRUE(matchAndVerifyResultTrue(
3557      "template <typename T> struct C {"
3558      "  void f(int) {"
3559      "    struct I { void g(T) { int x; } } i; i.g(42);"
3560      "  }"
3561      "};"
3562      "template struct C<int>;",
3563      varDecl(hasName("x"),
3564              hasAncestor(functionDecl(hasParameter(
3565                  0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
3566      new VerifyIdIsBoundTo<FunctionDecl>("f", "g", 2)));
3567}
3568
3569TEST(HasAncestor, MatchesInTemplateInstantiations) {
3570  EXPECT_TRUE(matches(
3571      "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
3572      "A<int>::B::C a;",
3573      fieldDecl(hasType(asString("int")),
3574                hasAncestor(recordDecl(hasName("A"))))));
3575}
3576
3577TEST(HasAncestor, MatchesInImplicitCode) {
3578  EXPECT_TRUE(matches(
3579      "struct X {}; struct A { A() {} X x; };",
3580      constructorDecl(
3581          hasAnyConstructorInitializer(withInitializer(expr(
3582              hasAncestor(recordDecl(hasName("A")))))))));
3583}
3584
3585TEST(HasParent, MatchesOnlyParent) {
3586  EXPECT_TRUE(matches(
3587      "void f() { if (true) { int x = 42; } }",
3588      compoundStmt(hasParent(ifStmt()))));
3589  EXPECT_TRUE(notMatches(
3590      "void f() { for (;;) { int x = 42; } }",
3591      compoundStmt(hasParent(ifStmt()))));
3592  EXPECT_TRUE(notMatches(
3593      "void f() { if (true) for (;;) { int x = 42; } }",
3594      compoundStmt(hasParent(ifStmt()))));
3595}
3596
3597TEST(HasAncestor, MatchesAllAncestors) {
3598  EXPECT_TRUE(matches(
3599      "template <typename T> struct C { static void f() { 42; } };"
3600      "void t() { C<int>::f(); }",
3601      integerLiteral(
3602          equals(42),
3603          allOf(hasAncestor(recordDecl(isTemplateInstantiation())),
3604                hasAncestor(recordDecl(unless(isTemplateInstantiation())))))));
3605}
3606
3607TEST(HasParent, MatchesAllParents) {
3608  EXPECT_TRUE(matches(
3609      "template <typename T> struct C { static void f() { 42; } };"
3610      "void t() { C<int>::f(); }",
3611      integerLiteral(
3612          equals(42),
3613          hasParent(compoundStmt(hasParent(functionDecl(
3614              hasParent(recordDecl(isTemplateInstantiation())))))))));
3615  EXPECT_TRUE(matches(
3616      "template <typename T> struct C { static void f() { 42; } };"
3617      "void t() { C<int>::f(); }",
3618      integerLiteral(
3619          equals(42),
3620          hasParent(compoundStmt(hasParent(functionDecl(
3621              hasParent(recordDecl(unless(isTemplateInstantiation()))))))))));
3622  EXPECT_TRUE(matches(
3623      "template <typename T> struct C { static void f() { 42; } };"
3624      "void t() { C<int>::f(); }",
3625      integerLiteral(equals(42),
3626                     hasParent(compoundStmt(allOf(
3627                         hasParent(functionDecl(
3628                             hasParent(recordDecl(isTemplateInstantiation())))),
3629                         hasParent(functionDecl(hasParent(recordDecl(
3630                             unless(isTemplateInstantiation())))))))))));
3631  EXPECT_TRUE(
3632      notMatches("template <typename T> struct C { static void f() {} };"
3633                 "void t() { C<int>::f(); }",
3634                 compoundStmt(hasParent(recordDecl()))));
3635}
3636
3637TEST(HasParent, NoDuplicateParents) {
3638  class HasDuplicateParents : public BoundNodesCallback {
3639  public:
3640    bool run(const BoundNodes *Nodes) override { return false; }
3641    bool run(const BoundNodes *Nodes, ASTContext *Context) override {
3642      const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
3643      std::set<const void *> Parents;
3644      for (const auto &Parent : Context->getParents(*Node)) {
3645        if (!Parents.insert(Parent.getMemoizationData()).second) {
3646          return true;
3647        }
3648      }
3649      return false;
3650    }
3651  };
3652  EXPECT_FALSE(matchAndVerifyResultTrue(
3653      "template <typename T> int Foo() { return 1 + 2; }\n"
3654      "int x = Foo<int>() + Foo<unsigned>();",
3655      stmt().bind("node"), new HasDuplicateParents()));
3656}
3657
3658TEST(TypeMatching, MatchesTypes) {
3659  EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
3660}
3661
3662TEST(TypeMatching, MatchesArrayTypes) {
3663  EXPECT_TRUE(matches("int a[] = {2,3};", arrayType()));
3664  EXPECT_TRUE(matches("int a[42];", arrayType()));
3665  EXPECT_TRUE(matches("void f(int b) { int a[b]; }", arrayType()));
3666
3667  EXPECT_TRUE(notMatches("struct A {}; A a[7];",
3668                         arrayType(hasElementType(builtinType()))));
3669
3670  EXPECT_TRUE(matches(
3671      "int const a[] = { 2, 3 };",
3672      qualType(arrayType(hasElementType(builtinType())))));
3673  EXPECT_TRUE(matches(
3674      "int const a[] = { 2, 3 };",
3675      qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
3676  EXPECT_TRUE(matches(
3677      "typedef const int T; T x[] = { 1, 2 };",
3678      qualType(isConstQualified(), arrayType())));
3679
3680  EXPECT_TRUE(notMatches(
3681      "int a[] = { 2, 3 };",
3682      qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
3683  EXPECT_TRUE(notMatches(
3684      "int a[] = { 2, 3 };",
3685      qualType(arrayType(hasElementType(isConstQualified(), builtinType())))));
3686  EXPECT_TRUE(notMatches(
3687      "int const a[] = { 2, 3 };",
3688      qualType(arrayType(hasElementType(builtinType())),
3689               unless(isConstQualified()))));
3690
3691  EXPECT_TRUE(matches("int a[2];",
3692                      constantArrayType(hasElementType(builtinType()))));
3693  EXPECT_TRUE(matches("const int a = 0;", qualType(isInteger())));
3694}
3695
3696TEST(TypeMatching, MatchesComplexTypes) {
3697  EXPECT_TRUE(matches("_Complex float f;", complexType()));
3698  EXPECT_TRUE(matches(
3699    "_Complex float f;",
3700    complexType(hasElementType(builtinType()))));
3701  EXPECT_TRUE(notMatches(
3702    "_Complex float f;",
3703    complexType(hasElementType(isInteger()))));
3704}
3705
3706TEST(TypeMatching, MatchesConstantArrayTypes) {
3707  EXPECT_TRUE(matches("int a[2];", constantArrayType()));
3708  EXPECT_TRUE(notMatches(
3709    "void f() { int a[] = { 2, 3 }; int b[a[0]]; }",
3710    constantArrayType(hasElementType(builtinType()))));
3711
3712  EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));
3713  EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
3714  EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));
3715}
3716
3717TEST(TypeMatching, MatchesDependentSizedArrayTypes) {
3718  EXPECT_TRUE(matches(
3719    "template <typename T, int Size> class array { T data[Size]; };",
3720    dependentSizedArrayType()));
3721  EXPECT_TRUE(notMatches(
3722    "int a[42]; int b[] = { 2, 3 }; void f() { int c[b[0]]; }",
3723    dependentSizedArrayType()));
3724}
3725
3726TEST(TypeMatching, MatchesIncompleteArrayType) {
3727  EXPECT_TRUE(matches("int a[] = { 2, 3 };", incompleteArrayType()));
3728  EXPECT_TRUE(matches("void f(int a[]) {}", incompleteArrayType()));
3729
3730  EXPECT_TRUE(notMatches("int a[42]; void f() { int b[a[0]]; }",
3731                         incompleteArrayType()));
3732}
3733
3734TEST(TypeMatching, MatchesVariableArrayType) {
3735  EXPECT_TRUE(matches("void f(int b) { int a[b]; }", variableArrayType()));
3736  EXPECT_TRUE(notMatches("int a[] = {2, 3}; int b[42];", variableArrayType()));
3737
3738  EXPECT_TRUE(matches(
3739    "void f(int b) { int a[b]; }",
3740    variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
3741      varDecl(hasName("b")))))))));
3742}
3743
3744TEST(TypeMatching, MatchesAtomicTypes) {
3745  if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
3746      llvm::Triple::Win32) {
3747    // FIXME: Make this work for MSVC.
3748    EXPECT_TRUE(matches("_Atomic(int) i;", atomicType()));
3749
3750    EXPECT_TRUE(matches("_Atomic(int) i;",
3751                        atomicType(hasValueType(isInteger()))));
3752    EXPECT_TRUE(notMatches("_Atomic(float) f;",
3753                           atomicType(hasValueType(isInteger()))));
3754  }
3755}
3756
3757TEST(TypeMatching, MatchesAutoTypes) {
3758  EXPECT_TRUE(matches("auto i = 2;", autoType()));
3759  EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
3760                      autoType()));
3761
3762  // FIXME: Matching against the type-as-written can't work here, because the
3763  //        type as written was not deduced.
3764  //EXPECT_TRUE(matches("auto a = 1;",
3765  //                    autoType(hasDeducedType(isInteger()))));
3766  //EXPECT_TRUE(notMatches("auto b = 2.0;",
3767  //                       autoType(hasDeducedType(isInteger()))));
3768}
3769
3770TEST(TypeMatching, MatchesFunctionTypes) {
3771  EXPECT_TRUE(matches("int (*f)(int);", functionType()));
3772  EXPECT_TRUE(matches("void f(int i) {}", functionType()));
3773}
3774
3775TEST(TypeMatching, MatchesParenType) {
3776  EXPECT_TRUE(
3777      matches("int (*array)[4];", varDecl(hasType(pointsTo(parenType())))));
3778  EXPECT_TRUE(notMatches("int *array[4];", varDecl(hasType(parenType()))));
3779
3780  EXPECT_TRUE(matches(
3781      "int (*ptr_to_func)(int);",
3782      varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
3783  EXPECT_TRUE(notMatches(
3784      "int (*ptr_to_array)[4];",
3785      varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
3786}
3787
3788TEST(TypeMatching, PointerTypes) {
3789  // FIXME: Reactive when these tests can be more specific (not matching
3790  // implicit code on certain platforms), likely when we have hasDescendant for
3791  // Types/TypeLocs.
3792  //EXPECT_TRUE(matchAndVerifyResultTrue(
3793  //    "int* a;",
3794  //    pointerTypeLoc(pointeeLoc(typeLoc().bind("loc"))),
3795  //    new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
3796  //EXPECT_TRUE(matchAndVerifyResultTrue(
3797  //    "int* a;",
3798  //    pointerTypeLoc().bind("loc"),
3799  //    new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
3800  EXPECT_TRUE(matches(
3801      "int** a;",
3802      loc(pointerType(pointee(qualType())))));
3803  EXPECT_TRUE(matches(
3804      "int** a;",
3805      loc(pointerType(pointee(pointerType())))));
3806  EXPECT_TRUE(matches(
3807      "int* b; int* * const a = &b;",
3808      loc(qualType(isConstQualified(), pointerType()))));
3809
3810  std::string Fragment = "struct A { int i; }; int A::* ptr = &A::i;";
3811  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3812                                           hasType(blockPointerType()))));
3813  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
3814                                        hasType(memberPointerType()))));
3815  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3816                                           hasType(pointerType()))));
3817  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3818                                           hasType(referenceType()))));
3819  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3820                                           hasType(lValueReferenceType()))));
3821  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3822                                           hasType(rValueReferenceType()))));
3823
3824  Fragment = "int *ptr;";
3825  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3826                                           hasType(blockPointerType()))));
3827  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3828                                           hasType(memberPointerType()))));
3829  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
3830                                        hasType(pointerType()))));
3831  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3832                                           hasType(referenceType()))));
3833
3834  Fragment = "int a; int &ref = a;";
3835  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3836                                           hasType(blockPointerType()))));
3837  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3838                                           hasType(memberPointerType()))));
3839  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3840                                           hasType(pointerType()))));
3841  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
3842                                        hasType(referenceType()))));
3843  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
3844                                        hasType(lValueReferenceType()))));
3845  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3846                                           hasType(rValueReferenceType()))));
3847
3848  Fragment = "int &&ref = 2;";
3849  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3850                                           hasType(blockPointerType()))));
3851  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3852                                           hasType(memberPointerType()))));
3853  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3854                                           hasType(pointerType()))));
3855  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
3856                                        hasType(referenceType()))));
3857  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3858                                           hasType(lValueReferenceType()))));
3859  EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
3860                                        hasType(rValueReferenceType()))));
3861}
3862
3863TEST(TypeMatching, AutoRefTypes) {
3864  std::string Fragment = "auto a = 1;"
3865                         "auto b = a;"
3866                         "auto &c = a;"
3867                         "auto &&d = c;"
3868                         "auto &&e = 2;";
3869  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("a"),
3870                                           hasType(referenceType()))));
3871  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("b"),
3872                                           hasType(referenceType()))));
3873  EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
3874                                        hasType(referenceType()))));
3875  EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
3876                                        hasType(lValueReferenceType()))));
3877  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("c"),
3878                                           hasType(rValueReferenceType()))));
3879  EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
3880                                        hasType(referenceType()))));
3881  EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
3882                                        hasType(lValueReferenceType()))));
3883  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("d"),
3884                                           hasType(rValueReferenceType()))));
3885  EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
3886                                        hasType(referenceType()))));
3887  EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("e"),
3888                                           hasType(lValueReferenceType()))));
3889  EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
3890                                        hasType(rValueReferenceType()))));
3891}
3892
3893TEST(TypeMatching, PointeeTypes) {
3894  EXPECT_TRUE(matches("int b; int &a = b;",
3895                      referenceType(pointee(builtinType()))));
3896  EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));
3897
3898  EXPECT_TRUE(matches("int *a;",
3899                      loc(pointerType(pointee(builtinType())))));
3900
3901  EXPECT_TRUE(matches(
3902      "int const *A;",
3903      pointerType(pointee(isConstQualified(), builtinType()))));
3904  EXPECT_TRUE(notMatches(
3905      "int *A;",
3906      pointerType(pointee(isConstQualified(), builtinType()))));
3907}
3908
3909TEST(TypeMatching, MatchesPointersToConstTypes) {
3910  EXPECT_TRUE(matches("int b; int * const a = &b;",
3911                      loc(pointerType())));
3912  EXPECT_TRUE(matches("int b; int * const a = &b;",
3913                      loc(pointerType())));
3914  EXPECT_TRUE(matches(
3915      "int b; const int * a = &b;",
3916      loc(pointerType(pointee(builtinType())))));
3917  EXPECT_TRUE(matches(
3918      "int b; const int * a = &b;",
3919      pointerType(pointee(builtinType()))));
3920}
3921
3922TEST(TypeMatching, MatchesTypedefTypes) {
3923  EXPECT_TRUE(matches("typedef int X; X a;", varDecl(hasName("a"),
3924                                                     hasType(typedefType()))));
3925}
3926
3927TEST(TypeMatching, MatchesTemplateSpecializationType) {
3928  EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
3929                      templateSpecializationType()));
3930}
3931
3932TEST(TypeMatching, MatchesRecordType) {
3933  EXPECT_TRUE(matches("class C{}; C c;", recordType()));
3934  EXPECT_TRUE(matches("struct S{}; S s;",
3935                      recordType(hasDeclaration(recordDecl(hasName("S"))))));
3936  EXPECT_TRUE(notMatches("int i;",
3937                         recordType(hasDeclaration(recordDecl(hasName("S"))))));
3938}
3939
3940TEST(TypeMatching, MatchesElaboratedType) {
3941  EXPECT_TRUE(matches(
3942    "namespace N {"
3943    "  namespace M {"
3944    "    class D {};"
3945    "  }"
3946    "}"
3947    "N::M::D d;", elaboratedType()));
3948  EXPECT_TRUE(matches("class C {} c;", elaboratedType()));
3949  EXPECT_TRUE(notMatches("class C {}; C c;", elaboratedType()));
3950}
3951
3952TEST(ElaboratedTypeNarrowing, hasQualifier) {
3953  EXPECT_TRUE(matches(
3954    "namespace N {"
3955    "  namespace M {"
3956    "    class D {};"
3957    "  }"
3958    "}"
3959    "N::M::D d;",
3960    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
3961  EXPECT_TRUE(notMatches(
3962    "namespace M {"
3963    "  class D {};"
3964    "}"
3965    "M::D d;",
3966    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
3967  EXPECT_TRUE(notMatches(
3968    "struct D {"
3969    "} d;",
3970    elaboratedType(hasQualifier(nestedNameSpecifier()))));
3971}
3972
3973TEST(ElaboratedTypeNarrowing, namesType) {
3974  EXPECT_TRUE(matches(
3975    "namespace N {"
3976    "  namespace M {"
3977    "    class D {};"
3978    "  }"
3979    "}"
3980    "N::M::D d;",
3981    elaboratedType(elaboratedType(namesType(recordType(
3982        hasDeclaration(namedDecl(hasName("D")))))))));
3983  EXPECT_TRUE(notMatches(
3984    "namespace M {"
3985    "  class D {};"
3986    "}"
3987    "M::D d;",
3988    elaboratedType(elaboratedType(namesType(typedefType())))));
3989}
3990
3991TEST(NNS, MatchesNestedNameSpecifiers) {
3992  EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;",
3993                      nestedNameSpecifier()));
3994  EXPECT_TRUE(matches("template <typename T> class A { typename T::B b; };",
3995                      nestedNameSpecifier()));
3996  EXPECT_TRUE(matches("struct A { void f(); }; void A::f() {}",
3997                      nestedNameSpecifier()));
3998
3999  EXPECT_TRUE(matches(
4000    "struct A { static void f() {} }; void g() { A::f(); }",
4001    nestedNameSpecifier()));
4002  EXPECT_TRUE(notMatches(
4003    "struct A { static void f() {} }; void g(A* a) { a->f(); }",
4004    nestedNameSpecifier()));
4005}
4006
4007TEST(NullStatement, SimpleCases) {
4008  EXPECT_TRUE(matches("void f() {int i;;}", nullStmt()));
4009  EXPECT_TRUE(notMatches("void f() {int i;}", nullStmt()));
4010}
4011
4012TEST(NNS, MatchesTypes) {
4013  NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
4014    specifiesType(hasDeclaration(recordDecl(hasName("A")))));
4015  EXPECT_TRUE(matches("struct A { struct B {}; }; A::B b;", Matcher));
4016  EXPECT_TRUE(matches("struct A { struct B { struct C {}; }; }; A::B::C c;",
4017                      Matcher));
4018  EXPECT_TRUE(notMatches("namespace A { struct B {}; } A::B b;", Matcher));
4019}
4020
4021TEST(NNS, MatchesNamespaceDecls) {
4022  NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
4023    specifiesNamespace(hasName("ns")));
4024  EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;", Matcher));
4025  EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
4026  EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
4027}
4028
4029TEST(NNS, BindsNestedNameSpecifiers) {
4030  EXPECT_TRUE(matchAndVerifyResultTrue(
4031      "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
4032      nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
4033      new VerifyIdIsBoundTo<NestedNameSpecifier>("nns", "ns::struct E::")));
4034}
4035
4036TEST(NNS, BindsNestedNameSpecifierLocs) {
4037  EXPECT_TRUE(matchAndVerifyResultTrue(
4038      "namespace ns { struct B {}; } ns::B b;",
4039      loc(nestedNameSpecifier()).bind("loc"),
4040      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("loc", 1)));
4041}
4042
4043TEST(NNS, MatchesNestedNameSpecifierPrefixes) {
4044  EXPECT_TRUE(matches(
4045      "struct A { struct B { struct C {}; }; }; A::B::C c;",
4046      nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A"))))));
4047  EXPECT_TRUE(matches(
4048      "struct A { struct B { struct C {}; }; }; A::B::C c;",
4049      nestedNameSpecifierLoc(hasPrefix(
4050          specifiesTypeLoc(loc(qualType(asString("struct A"))))))));
4051}
4052
4053TEST(NNS, DescendantsOfNestedNameSpecifiers) {
4054  std::string Fragment =
4055      "namespace a { struct A { struct B { struct C {}; }; }; };"
4056      "void f() { a::A::B::C c; }";
4057  EXPECT_TRUE(matches(
4058      Fragment,
4059      nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
4060                          hasDescendant(nestedNameSpecifier(
4061                              specifiesNamespace(hasName("a")))))));
4062  EXPECT_TRUE(notMatches(
4063      Fragment,
4064      nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
4065                          has(nestedNameSpecifier(
4066                              specifiesNamespace(hasName("a")))))));
4067  EXPECT_TRUE(matches(
4068      Fragment,
4069      nestedNameSpecifier(specifiesType(asString("struct a::A")),
4070                          has(nestedNameSpecifier(
4071                              specifiesNamespace(hasName("a")))))));
4072
4073  // Not really useful because a NestedNameSpecifier can af at most one child,
4074  // but to complete the interface.
4075  EXPECT_TRUE(matchAndVerifyResultTrue(
4076      Fragment,
4077      nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
4078                          forEach(nestedNameSpecifier().bind("x"))),
4079      new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 1)));
4080}
4081
4082TEST(NNS, NestedNameSpecifiersAsDescendants) {
4083  std::string Fragment =
4084      "namespace a { struct A { struct B { struct C {}; }; }; };"
4085      "void f() { a::A::B::C c; }";
4086  EXPECT_TRUE(matches(
4087      Fragment,
4088      decl(hasDescendant(nestedNameSpecifier(specifiesType(
4089          asString("struct a::A")))))));
4090  EXPECT_TRUE(matchAndVerifyResultTrue(
4091      Fragment,
4092      functionDecl(hasName("f"),
4093                   forEachDescendant(nestedNameSpecifier().bind("x"))),
4094      // Nested names: a, a::A and a::A::B.
4095      new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 3)));
4096}
4097
4098TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
4099  std::string Fragment =
4100      "namespace a { struct A { struct B { struct C {}; }; }; };"
4101      "void f() { a::A::B::C c; }";
4102  EXPECT_TRUE(matches(
4103      Fragment,
4104      nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
4105                             hasDescendant(loc(nestedNameSpecifier(
4106                                 specifiesNamespace(hasName("a"))))))));
4107  EXPECT_TRUE(notMatches(
4108      Fragment,
4109      nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
4110                             has(loc(nestedNameSpecifier(
4111                                 specifiesNamespace(hasName("a"))))))));
4112  EXPECT_TRUE(matches(
4113      Fragment,
4114      nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
4115                             has(loc(nestedNameSpecifier(
4116                                 specifiesNamespace(hasName("a"))))))));
4117
4118  EXPECT_TRUE(matchAndVerifyResultTrue(
4119      Fragment,
4120      nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
4121                             forEach(nestedNameSpecifierLoc().bind("x"))),
4122      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 1)));
4123}
4124
4125TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
4126  std::string Fragment =
4127      "namespace a { struct A { struct B { struct C {}; }; }; };"
4128      "void f() { a::A::B::C c; }";
4129  EXPECT_TRUE(matches(
4130      Fragment,
4131      decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
4132          asString("struct a::A"))))))));
4133  EXPECT_TRUE(matchAndVerifyResultTrue(
4134      Fragment,
4135      functionDecl(hasName("f"),
4136                   forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
4137      // Nested names: a, a::A and a::A::B.
4138      new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 3)));
4139}
4140
4141template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
4142public:
4143  VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
4144                    StringRef InnerId)
4145      : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
4146  }
4147
4148  virtual bool run(const BoundNodes *Nodes) { return false; }
4149
4150  virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
4151    const T *Node = Nodes->getNodeAs<T>(Id);
4152    return selectFirst<const T>(InnerId,
4153                                match(InnerMatcher, *Node, *Context)) !=nullptr;
4154  }
4155private:
4156  std::string Id;
4157  internal::Matcher<T> InnerMatcher;
4158  std::string InnerId;
4159};
4160
4161TEST(MatchFinder, CanMatchDeclarationsRecursively) {
4162  EXPECT_TRUE(matchAndVerifyResultTrue(
4163      "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
4164      new VerifyMatchOnNode<clang::Decl>(
4165          "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
4166          "Y")));
4167  EXPECT_TRUE(matchAndVerifyResultFalse(
4168      "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
4169      new VerifyMatchOnNode<clang::Decl>(
4170          "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
4171          "Z")));
4172}
4173
4174TEST(MatchFinder, CanMatchStatementsRecursively) {
4175  EXPECT_TRUE(matchAndVerifyResultTrue(
4176      "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
4177      new VerifyMatchOnNode<clang::Stmt>(
4178          "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
4179  EXPECT_TRUE(matchAndVerifyResultFalse(
4180      "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
4181      new VerifyMatchOnNode<clang::Stmt>(
4182          "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
4183}
4184
4185TEST(MatchFinder, CanMatchSingleNodesRecursively) {
4186  EXPECT_TRUE(matchAndVerifyResultTrue(
4187      "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
4188      new VerifyMatchOnNode<clang::Decl>(
4189          "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
4190  EXPECT_TRUE(matchAndVerifyResultFalse(
4191      "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
4192      new VerifyMatchOnNode<clang::Decl>(
4193          "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
4194}
4195
4196template <typename T>
4197class VerifyAncestorHasChildIsEqual : public BoundNodesCallback {
4198public:
4199  virtual bool run(const BoundNodes *Nodes) { return false; }
4200
4201  virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
4202    const T *Node = Nodes->getNodeAs<T>("");
4203    return verify(*Nodes, *Context, Node);
4204  }
4205
4206  bool verify(const BoundNodes &Nodes, ASTContext &Context, const Stmt *Node) {
4207    // Use the original typed pointer to verify we can pass pointers to subtypes
4208    // to equalsNode.
4209    const T *TypedNode = cast<T>(Node);
4210    return selectFirst<const T>(
4211               "", match(stmt(hasParent(
4212                             stmt(has(stmt(equalsNode(TypedNode)))).bind(""))),
4213                         *Node, Context)) != nullptr;
4214  }
4215  bool verify(const BoundNodes &Nodes, ASTContext &Context, const Decl *Node) {
4216    // Use the original typed pointer to verify we can pass pointers to subtypes
4217    // to equalsNode.
4218    const T *TypedNode = cast<T>(Node);
4219    return selectFirst<const T>(
4220               "", match(decl(hasParent(
4221                             decl(has(decl(equalsNode(TypedNode)))).bind(""))),
4222                         *Node, Context)) != nullptr;
4223  }
4224};
4225
4226TEST(IsEqualTo, MatchesNodesByIdentity) {
4227  EXPECT_TRUE(matchAndVerifyResultTrue(
4228      "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
4229      new VerifyAncestorHasChildIsEqual<CXXRecordDecl>()));
4230  EXPECT_TRUE(matchAndVerifyResultTrue(
4231      "void f() { if (true) if(true) {} }", ifStmt().bind(""),
4232      new VerifyAncestorHasChildIsEqual<IfStmt>()));
4233}
4234
4235class VerifyStartOfTranslationUnit : public MatchFinder::MatchCallback {
4236public:
4237  VerifyStartOfTranslationUnit() : Called(false) {}
4238  virtual void run(const MatchFinder::MatchResult &Result) {
4239    EXPECT_TRUE(Called);
4240  }
4241  virtual void onStartOfTranslationUnit() {
4242    Called = true;
4243  }
4244  bool Called;
4245};
4246
4247TEST(MatchFinder, InterceptsStartOfTranslationUnit) {
4248  MatchFinder Finder;
4249  VerifyStartOfTranslationUnit VerifyCallback;
4250  Finder.addMatcher(decl(), &VerifyCallback);
4251  std::unique_ptr<FrontendActionFactory> Factory(
4252      newFrontendActionFactory(&Finder));
4253  ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
4254  EXPECT_TRUE(VerifyCallback.Called);
4255
4256  VerifyCallback.Called = false;
4257  std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
4258  ASSERT_TRUE(AST.get());
4259  Finder.matchAST(AST->getASTContext());
4260  EXPECT_TRUE(VerifyCallback.Called);
4261}
4262
4263class VerifyEndOfTranslationUnit : public MatchFinder::MatchCallback {
4264public:
4265  VerifyEndOfTranslationUnit() : Called(false) {}
4266  virtual void run(const MatchFinder::MatchResult &Result) {
4267    EXPECT_FALSE(Called);
4268  }
4269  virtual void onEndOfTranslationUnit() {
4270    Called = true;
4271  }
4272  bool Called;
4273};
4274
4275TEST(MatchFinder, InterceptsEndOfTranslationUnit) {
4276  MatchFinder Finder;
4277  VerifyEndOfTranslationUnit VerifyCallback;
4278  Finder.addMatcher(decl(), &VerifyCallback);
4279  std::unique_ptr<FrontendActionFactory> Factory(
4280      newFrontendActionFactory(&Finder));
4281  ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
4282  EXPECT_TRUE(VerifyCallback.Called);
4283
4284  VerifyCallback.Called = false;
4285  std::unique_ptr<ASTUnit> AST(tooling::buildASTFromCode("int x;"));
4286  ASSERT_TRUE(AST.get());
4287  Finder.matchAST(AST->getASTContext());
4288  EXPECT_TRUE(VerifyCallback.Called);
4289}
4290
4291TEST(EqualsBoundNodeMatcher, QualType) {
4292  EXPECT_TRUE(matches(
4293      "int i = 1;", varDecl(hasType(qualType().bind("type")),
4294                            hasInitializer(ignoringParenImpCasts(
4295                                hasType(qualType(equalsBoundNode("type"))))))));
4296  EXPECT_TRUE(notMatches("int i = 1.f;",
4297                         varDecl(hasType(qualType().bind("type")),
4298                                 hasInitializer(ignoringParenImpCasts(hasType(
4299                                     qualType(equalsBoundNode("type"))))))));
4300}
4301
4302TEST(EqualsBoundNodeMatcher, NonMatchingTypes) {
4303  EXPECT_TRUE(notMatches(
4304      "int i = 1;", varDecl(namedDecl(hasName("i")).bind("name"),
4305                            hasInitializer(ignoringParenImpCasts(
4306                                hasType(qualType(equalsBoundNode("type"))))))));
4307}
4308
4309TEST(EqualsBoundNodeMatcher, Stmt) {
4310  EXPECT_TRUE(
4311      matches("void f() { if(true) {} }",
4312              stmt(allOf(ifStmt().bind("if"),
4313                         hasParent(stmt(has(stmt(equalsBoundNode("if")))))))));
4314
4315  EXPECT_TRUE(notMatches(
4316      "void f() { if(true) { if (true) {} } }",
4317      stmt(allOf(ifStmt().bind("if"), has(stmt(equalsBoundNode("if")))))));
4318}
4319
4320TEST(EqualsBoundNodeMatcher, Decl) {
4321  EXPECT_TRUE(matches(
4322      "class X { class Y {}; };",
4323      decl(allOf(recordDecl(hasName("::X::Y")).bind("record"),
4324                 hasParent(decl(has(decl(equalsBoundNode("record")))))))));
4325
4326  EXPECT_TRUE(notMatches("class X { class Y {}; };",
4327                         decl(allOf(recordDecl(hasName("::X")).bind("record"),
4328                                    has(decl(equalsBoundNode("record")))))));
4329}
4330
4331TEST(EqualsBoundNodeMatcher, Type) {
4332  EXPECT_TRUE(matches(
4333      "class X { int a; int b; };",
4334      recordDecl(
4335          has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
4336          has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
4337
4338  EXPECT_TRUE(notMatches(
4339      "class X { int a; double b; };",
4340      recordDecl(
4341          has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
4342          has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
4343}
4344
4345TEST(EqualsBoundNodeMatcher, UsingForEachDescendant) {
4346  EXPECT_TRUE(matchAndVerifyResultTrue(
4347      "int f() {"
4348      "  if (1) {"
4349      "    int i = 9;"
4350      "  }"
4351      "  int j = 10;"
4352      "  {"
4353      "    float k = 9.0;"
4354      "  }"
4355      "  return 0;"
4356      "}",
4357      // Look for variable declarations within functions whose type is the same
4358      // as the function return type.
4359      functionDecl(returns(qualType().bind("type")),
4360                   forEachDescendant(varDecl(hasType(
4361                       qualType(equalsBoundNode("type")))).bind("decl"))),
4362      // Only i and j should match, not k.
4363      new VerifyIdIsBoundTo<VarDecl>("decl", 2)));
4364}
4365
4366TEST(EqualsBoundNodeMatcher, FiltersMatchedCombinations) {
4367  EXPECT_TRUE(matchAndVerifyResultTrue(
4368      "void f() {"
4369      "  int x;"
4370      "  double d;"
4371      "  x = d + x - d + x;"
4372      "}",
4373      functionDecl(
4374          hasName("f"), forEachDescendant(varDecl().bind("d")),
4375          forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d")))))),
4376      new VerifyIdIsBoundTo<VarDecl>("d", 5)));
4377}
4378
4379TEST(EqualsBoundNodeMatcher, UnlessDescendantsOfAncestorsMatch) {
4380  EXPECT_TRUE(matchAndVerifyResultTrue(
4381      "struct StringRef { int size() const; const char* data() const; };"
4382      "void f(StringRef v) {"
4383      "  v.data();"
4384      "}",
4385      memberCallExpr(
4386          callee(methodDecl(hasName("data"))),
4387          on(declRefExpr(to(varDecl(hasType(recordDecl(hasName("StringRef"))))
4388                                .bind("var")))),
4389          unless(hasAncestor(stmt(hasDescendant(memberCallExpr(
4390              callee(methodDecl(anyOf(hasName("size"), hasName("length")))),
4391              on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
4392          .bind("data"),
4393      new VerifyIdIsBoundTo<Expr>("data", 1)));
4394
4395  EXPECT_FALSE(matches(
4396      "struct StringRef { int size() const; const char* data() const; };"
4397      "void f(StringRef v) {"
4398      "  v.data();"
4399      "  v.size();"
4400      "}",
4401      memberCallExpr(
4402          callee(methodDecl(hasName("data"))),
4403          on(declRefExpr(to(varDecl(hasType(recordDecl(hasName("StringRef"))))
4404                                .bind("var")))),
4405          unless(hasAncestor(stmt(hasDescendant(memberCallExpr(
4406              callee(methodDecl(anyOf(hasName("size"), hasName("length")))),
4407              on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
4408          .bind("data")));
4409}
4410
4411} // end namespace ast_matchers
4412} // end namespace clang
4413