1// unittests/ASTMatchers/ASTMatchersNarrowingTest.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
23TEST(AllOf, AllOverloadsWork) {
24  const char Program[] =
25      "struct T { };"
26      "int f(int, T*, int, int);"
27      "void g(int x) { T t; f(x, &t, 3, 4); }";
28  EXPECT_TRUE(matches(Program,
29      callExpr(allOf(callee(functionDecl(hasName("f"))),
30                     hasArgument(0, declRefExpr(to(varDecl())))))));
31  EXPECT_TRUE(matches(Program,
32      callExpr(allOf(callee(functionDecl(hasName("f"))),
33                     hasArgument(0, declRefExpr(to(varDecl()))),
34                     hasArgument(1, hasType(pointsTo(
35                                        recordDecl(hasName("T")))))))));
36  EXPECT_TRUE(matches(Program,
37      callExpr(allOf(callee(functionDecl(hasName("f"))),
38                     hasArgument(0, declRefExpr(to(varDecl()))),
39                     hasArgument(1, hasType(pointsTo(
40                                        recordDecl(hasName("T"))))),
41                     hasArgument(2, integerLiteral(equals(3)))))));
42  EXPECT_TRUE(matches(Program,
43      callExpr(allOf(callee(functionDecl(hasName("f"))),
44                     hasArgument(0, declRefExpr(to(varDecl()))),
45                     hasArgument(1, hasType(pointsTo(
46                                        recordDecl(hasName("T"))))),
47                     hasArgument(2, integerLiteral(equals(3))),
48                     hasArgument(3, integerLiteral(equals(4)))))));
49}
50
51TEST(DeclarationMatcher, MatchHas) {
52  DeclarationMatcher HasClassX = recordDecl(has(recordDecl(hasName("X"))));
53  EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
54  EXPECT_TRUE(matches("class X {};", HasClassX));
55
56  DeclarationMatcher YHasClassX =
57    recordDecl(hasName("Y"), has(recordDecl(hasName("X"))));
58  EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
59  EXPECT_TRUE(notMatches("class X {};", YHasClassX));
60  EXPECT_TRUE(
61    notMatches("class Y { class Z { class X {}; }; };", YHasClassX));
62}
63
64TEST(DeclarationMatcher, MatchHasRecursiveAllOf) {
65  DeclarationMatcher Recursive =
66    recordDecl(
67      has(recordDecl(
68        has(recordDecl(hasName("X"))),
69        has(recordDecl(hasName("Y"))),
70        hasName("Z"))),
71      has(recordDecl(
72        has(recordDecl(hasName("A"))),
73        has(recordDecl(hasName("B"))),
74        hasName("C"))),
75      hasName("F"));
76
77  EXPECT_TRUE(matches(
78    "class F {"
79      "  class Z {"
80      "    class X {};"
81      "    class Y {};"
82      "  };"
83      "  class C {"
84      "    class A {};"
85      "    class B {};"
86      "  };"
87      "};", Recursive));
88
89  EXPECT_TRUE(matches(
90    "class F {"
91      "  class Z {"
92      "    class A {};"
93      "    class X {};"
94      "    class Y {};"
95      "  };"
96      "  class C {"
97      "    class X {};"
98      "    class A {};"
99      "    class B {};"
100      "  };"
101      "};", Recursive));
102
103  EXPECT_TRUE(matches(
104    "class O1 {"
105      "  class O2 {"
106      "    class F {"
107      "      class Z {"
108      "        class A {};"
109      "        class X {};"
110      "        class Y {};"
111      "      };"
112      "      class C {"
113      "        class X {};"
114      "        class A {};"
115      "        class B {};"
116      "      };"
117      "    };"
118      "  };"
119      "};", Recursive));
120}
121
122TEST(DeclarationMatcher, MatchHasRecursiveAnyOf) {
123  DeclarationMatcher Recursive =
124    recordDecl(
125      anyOf(
126        has(recordDecl(
127          anyOf(
128            has(recordDecl(
129              hasName("X"))),
130            has(recordDecl(
131              hasName("Y"))),
132            hasName("Z")))),
133        has(recordDecl(
134          anyOf(
135            hasName("C"),
136            has(recordDecl(
137              hasName("A"))),
138            has(recordDecl(
139              hasName("B")))))),
140        hasName("F")));
141
142  EXPECT_TRUE(matches("class F {};", Recursive));
143  EXPECT_TRUE(matches("class Z {};", Recursive));
144  EXPECT_TRUE(matches("class C {};", Recursive));
145  EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
146  EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
147  EXPECT_TRUE(
148    matches("class O1 { class O2 {"
149              "  class M { class N { class B {}; }; }; "
150              "}; };", Recursive));
151}
152
153TEST(DeclarationMatcher, MatchNot) {
154  DeclarationMatcher NotClassX =
155    cxxRecordDecl(
156      isDerivedFrom("Y"),
157      unless(hasName("X")));
158  EXPECT_TRUE(notMatches("", NotClassX));
159  EXPECT_TRUE(notMatches("class Y {};", NotClassX));
160  EXPECT_TRUE(matches("class Y {}; class Z : public Y {};", NotClassX));
161  EXPECT_TRUE(notMatches("class Y {}; class X : public Y {};", NotClassX));
162  EXPECT_TRUE(
163    notMatches("class Y {}; class Z {}; class X : public Y {};",
164               NotClassX));
165
166  DeclarationMatcher ClassXHasNotClassY =
167    recordDecl(
168      hasName("X"),
169      has(recordDecl(hasName("Z"))),
170      unless(
171        has(recordDecl(hasName("Y")))));
172  EXPECT_TRUE(matches("class X { class Z {}; };", ClassXHasNotClassY));
173  EXPECT_TRUE(notMatches("class X { class Y {}; class Z {}; };",
174                         ClassXHasNotClassY));
175
176  DeclarationMatcher NamedNotRecord =
177    namedDecl(hasName("Foo"), unless(recordDecl()));
178  EXPECT_TRUE(matches("void Foo(){}", NamedNotRecord));
179  EXPECT_TRUE(notMatches("struct Foo {};", NamedNotRecord));
180}
181
182TEST(CastExpression, HasCastKind) {
183  EXPECT_TRUE(matches("char *p = 0;",
184              castExpr(hasCastKind(CK_NullToPointer))));
185  EXPECT_TRUE(notMatches("char *p = 0;",
186              castExpr(hasCastKind(CK_DerivedToBase))));
187  EXPECT_TRUE(matches("char *p = 0;",
188              implicitCastExpr(hasCastKind(CK_NullToPointer))));
189}
190
191TEST(DeclarationMatcher, HasDescendant) {
192  DeclarationMatcher ZDescendantClassX =
193    recordDecl(
194      hasDescendant(recordDecl(hasName("X"))),
195      hasName("Z"));
196  EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
197  EXPECT_TRUE(
198    matches("class Z { class Y { class X {}; }; };", ZDescendantClassX));
199  EXPECT_TRUE(
200    matches("class Z { class A { class Y { class X {}; }; }; };",
201            ZDescendantClassX));
202  EXPECT_TRUE(
203    matches("class Z { class A { class B { class Y { class X {}; }; }; }; };",
204            ZDescendantClassX));
205  EXPECT_TRUE(notMatches("class Z {};", ZDescendantClassX));
206
207  DeclarationMatcher ZDescendantClassXHasClassY =
208    recordDecl(
209      hasDescendant(recordDecl(has(recordDecl(hasName("Y"))),
210                               hasName("X"))),
211      hasName("Z"));
212  EXPECT_TRUE(matches("class Z { class X { class Y {}; }; };",
213                      ZDescendantClassXHasClassY));
214  EXPECT_TRUE(
215    matches("class Z { class A { class B { class X { class Y {}; }; }; }; };",
216            ZDescendantClassXHasClassY));
217  EXPECT_TRUE(notMatches(
218    "class Z {"
219      "  class A {"
220      "    class B {"
221      "      class X {"
222      "        class C {"
223      "          class Y {};"
224      "        };"
225      "      };"
226      "    }; "
227      "  };"
228      "};", ZDescendantClassXHasClassY));
229
230  DeclarationMatcher ZDescendantClassXDescendantClassY =
231    recordDecl(
232      hasDescendant(recordDecl(hasDescendant(recordDecl(hasName("Y"))),
233                               hasName("X"))),
234      hasName("Z"));
235  EXPECT_TRUE(
236    matches("class Z { class A { class X { class B { class Y {}; }; }; }; };",
237            ZDescendantClassXDescendantClassY));
238  EXPECT_TRUE(matches(
239    "class Z {"
240      "  class A {"
241      "    class X {"
242      "      class B {"
243      "        class Y {};"
244      "      };"
245      "      class Y {};"
246      "    };"
247      "  };"
248      "};", ZDescendantClassXDescendantClassY));
249}
250
251TEST(DeclarationMatcher, HasDescendantMemoization) {
252  DeclarationMatcher CannotMemoize =
253    decl(hasDescendant(typeLoc().bind("x")), has(decl()));
254  EXPECT_TRUE(matches("void f() { int i; }", CannotMemoize));
255}
256
257TEST(DeclarationMatcher, HasDescendantMemoizationUsesRestrictKind) {
258  auto Name = hasName("i");
259  auto VD = internal::Matcher<VarDecl>(Name).dynCastTo<Decl>();
260  auto RD = internal::Matcher<RecordDecl>(Name).dynCastTo<Decl>();
261  // Matching VD first should not make a cache hit for RD.
262  EXPECT_TRUE(notMatches("void f() { int i; }",
263                         decl(hasDescendant(VD), hasDescendant(RD))));
264  EXPECT_TRUE(notMatches("void f() { int i; }",
265                         decl(hasDescendant(RD), hasDescendant(VD))));
266  // Not matching RD first should not make a cache hit for VD either.
267  EXPECT_TRUE(matches("void f() { int i; }",
268                      decl(anyOf(hasDescendant(RD), hasDescendant(VD)))));
269}
270
271TEST(DeclarationMatcher, HasAncestorMemoization) {
272  // This triggers an hasAncestor with a TemplateArgument in the bound nodes.
273  // That node can't be memoized so we have to check for it before trying to put
274  // it on the cache.
275  DeclarationMatcher CannotMemoize = classTemplateSpecializationDecl(
276    hasAnyTemplateArgument(templateArgument().bind("targ")),
277    forEach(fieldDecl(hasAncestor(forStmt()))));
278
279  EXPECT_TRUE(notMatches("template <typename T> struct S;"
280                           "template <> struct S<int>{ int i; int j; };",
281                         CannotMemoize));
282}
283
284TEST(DeclarationMatcher, HasAttr) {
285  EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};",
286                      decl(hasAttr(clang::attr::WarnUnused))));
287  EXPECT_FALSE(matches("struct X {};",
288                       decl(hasAttr(clang::attr::WarnUnused))));
289}
290
291
292TEST(DeclarationMatcher, MatchAnyOf) {
293  DeclarationMatcher YOrZDerivedFromX = cxxRecordDecl(
294    anyOf(hasName("Y"), allOf(isDerivedFrom("X"), hasName("Z"))));
295  EXPECT_TRUE(matches("class X {}; class Z : public X {};", YOrZDerivedFromX));
296  EXPECT_TRUE(matches("class Y {};", YOrZDerivedFromX));
297  EXPECT_TRUE(
298    notMatches("class X {}; class W : public X {};", YOrZDerivedFromX));
299  EXPECT_TRUE(notMatches("class Z {};", YOrZDerivedFromX));
300
301  DeclarationMatcher XOrYOrZOrU =
302    recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U")));
303  EXPECT_TRUE(matches("class X {};", XOrYOrZOrU));
304  EXPECT_TRUE(notMatches("class V {};", XOrYOrZOrU));
305
306  DeclarationMatcher XOrYOrZOrUOrV =
307    recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U"),
308                     hasName("V")));
309  EXPECT_TRUE(matches("class X {};", XOrYOrZOrUOrV));
310  EXPECT_TRUE(matches("class Y {};", XOrYOrZOrUOrV));
311  EXPECT_TRUE(matches("class Z {};", XOrYOrZOrUOrV));
312  EXPECT_TRUE(matches("class U {};", XOrYOrZOrUOrV));
313  EXPECT_TRUE(matches("class V {};", XOrYOrZOrUOrV));
314  EXPECT_TRUE(notMatches("class A {};", XOrYOrZOrUOrV));
315
316  StatementMatcher MixedTypes = stmt(anyOf(ifStmt(), binaryOperator()));
317  EXPECT_TRUE(matches("int F() { return 1 + 2; }", MixedTypes));
318  EXPECT_TRUE(matches("int F() { if (true) return 1; }", MixedTypes));
319  EXPECT_TRUE(notMatches("int F() { return 1; }", MixedTypes));
320
321  EXPECT_TRUE(
322    matches("void f() try { } catch (int) { } catch (...) { }",
323            cxxCatchStmt(anyOf(hasDescendant(varDecl()), isCatchAll()))));
324}
325
326TEST(DeclarationMatcher, ClassIsDerived) {
327  DeclarationMatcher IsDerivedFromX = cxxRecordDecl(isDerivedFrom("X"));
328
329  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
330  EXPECT_TRUE(notMatches("class X {};", IsDerivedFromX));
331  EXPECT_TRUE(notMatches("class X;", IsDerivedFromX));
332  EXPECT_TRUE(notMatches("class Y;", IsDerivedFromX));
333  EXPECT_TRUE(notMatches("", IsDerivedFromX));
334
335  DeclarationMatcher IsAX = cxxRecordDecl(isSameOrDerivedFrom("X"));
336
337  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsAX));
338  EXPECT_TRUE(matches("class X {};", IsAX));
339  EXPECT_TRUE(matches("class X;", IsAX));
340  EXPECT_TRUE(notMatches("class Y;", IsAX));
341  EXPECT_TRUE(notMatches("", IsAX));
342
343  DeclarationMatcher ZIsDerivedFromX =
344    cxxRecordDecl(hasName("Z"), isDerivedFrom("X"));
345  EXPECT_TRUE(
346    matches("class X {}; class Y : public X {}; class Z : public Y {};",
347            ZIsDerivedFromX));
348  EXPECT_TRUE(
349    matches("class X {};"
350              "template<class T> class Y : public X {};"
351              "class Z : public Y<int> {};", ZIsDerivedFromX));
352  EXPECT_TRUE(matches("class X {}; template<class T> class Z : public X {};",
353                      ZIsDerivedFromX));
354  EXPECT_TRUE(
355    matches("template<class T> class X {}; "
356              "template<class T> class Z : public X<T> {};",
357            ZIsDerivedFromX));
358  EXPECT_TRUE(
359    matches("template<class T, class U=T> class X {}; "
360              "template<class T> class Z : public X<T> {};",
361            ZIsDerivedFromX));
362  EXPECT_TRUE(
363    notMatches("template<class X> class A { class Z : public X {}; };",
364               ZIsDerivedFromX));
365  EXPECT_TRUE(
366    matches("template<class X> class A { public: class Z : public X {}; }; "
367              "class X{}; void y() { A<X>::Z z; }", ZIsDerivedFromX));
368  EXPECT_TRUE(
369    matches("template <class T> class X {}; "
370              "template<class Y> class A { class Z : public X<Y> {}; };",
371            ZIsDerivedFromX));
372  EXPECT_TRUE(
373    notMatches("template<template<class T> class X> class A { "
374                 "  class Z : public X<int> {}; };", ZIsDerivedFromX));
375  EXPECT_TRUE(
376    matches("template<template<class T> class X> class A { "
377              "  public: class Z : public X<int> {}; }; "
378              "template<class T> class X {}; void y() { A<X>::Z z; }",
379            ZIsDerivedFromX));
380  EXPECT_TRUE(
381    notMatches("template<class X> class A { class Z : public X::D {}; };",
382               ZIsDerivedFromX));
383  EXPECT_TRUE(
384    matches("template<class X> class A { public: "
385              "  class Z : public X::D {}; }; "
386              "class Y { public: class X {}; typedef X D; }; "
387              "void y() { A<Y>::Z z; }", ZIsDerivedFromX));
388  EXPECT_TRUE(
389    matches("class X {}; typedef X Y; class Z : public Y {};",
390            ZIsDerivedFromX));
391  EXPECT_TRUE(
392    matches("template<class T> class Y { typedef typename T::U X; "
393              "  class Z : public X {}; };", ZIsDerivedFromX));
394  EXPECT_TRUE(matches("class X {}; class Z : public ::X {};",
395                      ZIsDerivedFromX));
396  EXPECT_TRUE(
397    notMatches("template<class T> class X {}; "
398                 "template<class T> class A { class Z : public X<T>::D {}; };",
399               ZIsDerivedFromX));
400  EXPECT_TRUE(
401    matches("template<class T> class X { public: typedef X<T> D; }; "
402              "template<class T> class A { public: "
403              "  class Z : public X<T>::D {}; }; void y() { A<int>::Z z; }",
404            ZIsDerivedFromX));
405  EXPECT_TRUE(
406    notMatches("template<class X> class A { class Z : public X::D::E {}; };",
407               ZIsDerivedFromX));
408  EXPECT_TRUE(
409    matches("class X {}; typedef X V; typedef V W; class Z : public W {};",
410            ZIsDerivedFromX));
411  EXPECT_TRUE(
412    matches("class X {}; class Y : public X {}; "
413              "typedef Y V; typedef V W; class Z : public W {};",
414            ZIsDerivedFromX));
415  EXPECT_TRUE(
416    matches("template<class T, class U> class X {}; "
417              "template<class T> class A { class Z : public X<T, int> {}; };",
418            ZIsDerivedFromX));
419  EXPECT_TRUE(
420    notMatches("template<class X> class D { typedef X A; typedef A B; "
421                 "  typedef B C; class Z : public C {}; };",
422               ZIsDerivedFromX));
423  EXPECT_TRUE(
424    matches("class X {}; typedef X A; typedef A B; "
425              "class Z : public B {};", ZIsDerivedFromX));
426  EXPECT_TRUE(
427    matches("class X {}; typedef X A; typedef A B; typedef B C; "
428              "class Z : public C {};", ZIsDerivedFromX));
429  EXPECT_TRUE(
430    matches("class U {}; typedef U X; typedef X V; "
431              "class Z : public V {};", ZIsDerivedFromX));
432  EXPECT_TRUE(
433    matches("class Base {}; typedef Base X; "
434              "class Z : public Base {};", ZIsDerivedFromX));
435  EXPECT_TRUE(
436    matches("class Base {}; typedef Base Base2; typedef Base2 X; "
437              "class Z : public Base {};", ZIsDerivedFromX));
438  EXPECT_TRUE(
439    notMatches("class Base {}; class Base2 {}; typedef Base2 X; "
440                 "class Z : public Base {};", ZIsDerivedFromX));
441  EXPECT_TRUE(
442    matches("class A {}; typedef A X; typedef A Y; "
443              "class Z : public Y {};", ZIsDerivedFromX));
444  EXPECT_TRUE(
445    notMatches("template <typename T> class Z;"
446                 "template <> class Z<void> {};"
447                 "template <typename T> class Z : public Z<void> {};",
448               IsDerivedFromX));
449  EXPECT_TRUE(
450    matches("template <typename T> class X;"
451              "template <> class X<void> {};"
452              "template <typename T> class X : public X<void> {};",
453            IsDerivedFromX));
454  EXPECT_TRUE(matches(
455    "class X {};"
456      "template <typename T> class Z;"
457      "template <> class Z<void> {};"
458      "template <typename T> class Z : public Z<void>, public X {};",
459    ZIsDerivedFromX));
460  EXPECT_TRUE(
461    notMatches("template<int> struct X;"
462                 "template<int i> struct X : public X<i-1> {};",
463               cxxRecordDecl(isDerivedFrom(recordDecl(hasName("Some"))))));
464  EXPECT_TRUE(matches(
465    "struct A {};"
466      "template<int> struct X;"
467      "template<int i> struct X : public X<i-1> {};"
468      "template<> struct X<0> : public A {};"
469      "struct B : public X<42> {};",
470    cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl(hasName("A"))))));
471
472  // FIXME: Once we have better matchers for template type matching,
473  // get rid of the Variable(...) matching and match the right template
474  // declarations directly.
475  const char *RecursiveTemplateOneParameter =
476    "class Base1 {}; class Base2 {};"
477      "template <typename T> class Z;"
478      "template <> class Z<void> : public Base1 {};"
479      "template <> class Z<int> : public Base2 {};"
480      "template <> class Z<float> : public Z<void> {};"
481      "template <> class Z<double> : public Z<int> {};"
482      "template <typename T> class Z : public Z<float>, public Z<double> {};"
483      "void f() { Z<float> z_float; Z<double> z_double; Z<char> z_char; }";
484  EXPECT_TRUE(matches(
485    RecursiveTemplateOneParameter,
486    varDecl(hasName("z_float"),
487            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1")))))));
488  EXPECT_TRUE(notMatches(
489    RecursiveTemplateOneParameter,
490    varDecl(hasName("z_float"),
491            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base2")))))));
492  EXPECT_TRUE(matches(
493    RecursiveTemplateOneParameter,
494    varDecl(hasName("z_char"),
495            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1"),
496                                                 isDerivedFrom("Base2")))))));
497
498  const char *RecursiveTemplateTwoParameters =
499    "class Base1 {}; class Base2 {};"
500      "template <typename T1, typename T2> class Z;"
501      "template <typename T> class Z<void, T> : public Base1 {};"
502      "template <typename T> class Z<int, T> : public Base2 {};"
503      "template <typename T> class Z<float, T> : public Z<void, T> {};"
504      "template <typename T> class Z<double, T> : public Z<int, T> {};"
505      "template <typename T1, typename T2> class Z : "
506      "    public Z<float, T2>, public Z<double, T2> {};"
507      "void f() { Z<float, void> z_float; Z<double, void> z_double; "
508      "           Z<char, void> z_char; }";
509  EXPECT_TRUE(matches(
510    RecursiveTemplateTwoParameters,
511    varDecl(hasName("z_float"),
512            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1")))))));
513  EXPECT_TRUE(notMatches(
514    RecursiveTemplateTwoParameters,
515    varDecl(hasName("z_float"),
516            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base2")))))));
517  EXPECT_TRUE(matches(
518    RecursiveTemplateTwoParameters,
519    varDecl(hasName("z_char"),
520            hasInitializer(hasType(cxxRecordDecl(isDerivedFrom("Base1"),
521                                                 isDerivedFrom("Base2")))))));
522  EXPECT_TRUE(matches(
523    "namespace ns { class X {}; class Y : public X {}; }",
524    cxxRecordDecl(isDerivedFrom("::ns::X"))));
525  EXPECT_TRUE(notMatches(
526    "class X {}; class Y : public X {};",
527    cxxRecordDecl(isDerivedFrom("::ns::X"))));
528
529  EXPECT_TRUE(matches(
530    "class X {}; class Y : public X {};",
531    cxxRecordDecl(isDerivedFrom(recordDecl(hasName("X")).bind("test")))));
532
533  EXPECT_TRUE(matches(
534    "template<typename T> class X {};"
535      "template<typename T> using Z = X<T>;"
536      "template <typename T> class Y : Z<T> {};",
537    cxxRecordDecl(isDerivedFrom(namedDecl(hasName("X"))))));
538}
539
540TEST(DeclarationMatcher, IsLambda) {
541  const auto IsLambda = cxxMethodDecl(ofClass(cxxRecordDecl(isLambda())));
542  EXPECT_TRUE(matches("auto x = []{};", IsLambda));
543  EXPECT_TRUE(notMatches("struct S { void operator()() const; };", IsLambda));
544}
545
546TEST(Matcher, BindMatchedNodes) {
547  DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));
548
549  EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
550                                       ClassX, llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x")));
551
552  EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
553                                        ClassX, llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("other-id")));
554
555  TypeMatcher TypeAHasClassB = hasDeclaration(
556    recordDecl(hasName("A"), has(recordDecl(hasName("B")).bind("b"))));
557
558  EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
559                                       TypeAHasClassB,
560                                       llvm::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
561
562  StatementMatcher MethodX =
563    callExpr(callee(cxxMethodDecl(hasName("x")))).bind("x");
564
565  EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
566                                       MethodX,
567                                       llvm::make_unique<VerifyIdIsBoundTo<CXXMemberCallExpr>>("x")));
568}
569
570TEST(Matcher, BindTheSameNameInAlternatives) {
571  StatementMatcher matcher = anyOf(
572    binaryOperator(hasOperatorName("+"),
573                   hasLHS(expr().bind("x")),
574                   hasRHS(integerLiteral(equals(0)))),
575    binaryOperator(hasOperatorName("+"),
576                   hasLHS(integerLiteral(equals(0))),
577                   hasRHS(expr().bind("x"))));
578
579  EXPECT_TRUE(matchAndVerifyResultTrue(
580    // The first branch of the matcher binds x to 0 but then fails.
581    // The second branch binds x to f() and succeeds.
582    "int f() { return 0 + f(); }",
583    matcher,
584    llvm::make_unique<VerifyIdIsBoundTo<CallExpr>>("x")));
585}
586
587TEST(Matcher, BindsIDForMemoizedResults) {
588  // Using the same matcher in two match expressions will make memoization
589  // kick in.
590  DeclarationMatcher ClassX = recordDecl(hasName("X")).bind("x");
591  EXPECT_TRUE(matchAndVerifyResultTrue(
592    "class A { class B { class X {}; }; };",
593    DeclarationMatcher(anyOf(
594      recordDecl(hasName("A"), hasDescendant(ClassX)),
595      recordDecl(hasName("B"), hasDescendant(ClassX)))),
596    llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 2)));
597}
598
599TEST(HasType, MatchesAsString) {
600  EXPECT_TRUE(
601    matches("class Y { public: void x(); }; void z() {Y* y; y->x(); }",
602            cxxMemberCallExpr(on(hasType(asString("class Y *"))))));
603  EXPECT_TRUE(
604    matches("class X { void x(int x) {} };",
605            cxxMethodDecl(hasParameter(0, hasType(asString("int"))))));
606  EXPECT_TRUE(matches("namespace ns { struct A {}; }  struct B { ns::A a; };",
607                      fieldDecl(hasType(asString("ns::A")))));
608  EXPECT_TRUE(matches("namespace { struct A {}; }  struct B { A a; };",
609                      fieldDecl(hasType(asString("struct (anonymous namespace)::A")))));
610}
611
612TEST(Matcher, HasOperatorNameForOverloadedOperatorCall) {
613  StatementMatcher OpCallAndAnd =
614    cxxOperatorCallExpr(hasOverloadedOperatorName("&&"));
615  EXPECT_TRUE(matches("class Y { }; "
616                        "bool operator&&(Y x, Y y) { return true; }; "
617                        "Y a; Y b; bool c = a && b;", OpCallAndAnd));
618  StatementMatcher OpCallLessLess =
619    cxxOperatorCallExpr(hasOverloadedOperatorName("<<"));
620  EXPECT_TRUE(notMatches("class Y { }; "
621                           "bool operator&&(Y x, Y y) { return true; }; "
622                           "Y a; Y b; bool c = a && b;",
623                         OpCallLessLess));
624  StatementMatcher OpStarCall =
625    cxxOperatorCallExpr(hasOverloadedOperatorName("*"));
626  EXPECT_TRUE(matches("class Y; int operator*(Y &); void f(Y &y) { *y; }",
627                      OpStarCall));
628  DeclarationMatcher ClassWithOpStar =
629    cxxRecordDecl(hasMethod(hasOverloadedOperatorName("*")));
630  EXPECT_TRUE(matches("class Y { int operator*(); };",
631                      ClassWithOpStar));
632  EXPECT_TRUE(notMatches("class Y { void myOperator(); };",
633                         ClassWithOpStar)) ;
634  DeclarationMatcher AnyOpStar = functionDecl(hasOverloadedOperatorName("*"));
635  EXPECT_TRUE(matches("class Y; int operator*(Y &);", AnyOpStar));
636  EXPECT_TRUE(matches("class Y { int operator*(); };", AnyOpStar));
637}
638
639
640TEST(Matcher, NestedOverloadedOperatorCalls) {
641  EXPECT_TRUE(matchAndVerifyResultTrue(
642    "class Y { }; "
643      "Y& operator&&(Y& x, Y& y) { return x; }; "
644      "Y a; Y b; Y c; Y d = a && b && c;",
645    cxxOperatorCallExpr(hasOverloadedOperatorName("&&")).bind("x"),
646    llvm::make_unique<VerifyIdIsBoundTo<CXXOperatorCallExpr>>("x", 2)));
647  EXPECT_TRUE(matches("class Y { }; "
648                        "Y& operator&&(Y& x, Y& y) { return x; }; "
649                        "Y a; Y b; Y c; Y d = a && b && c;",
650                      cxxOperatorCallExpr(hasParent(cxxOperatorCallExpr()))));
651  EXPECT_TRUE(
652    matches("class Y { }; "
653              "Y& operator&&(Y& x, Y& y) { return x; }; "
654              "Y a; Y b; Y c; Y d = a && b && c;",
655            cxxOperatorCallExpr(hasDescendant(cxxOperatorCallExpr()))));
656}
657
658TEST(Matcher, VarDecl_Storage) {
659  auto M = varDecl(hasName("X"), hasLocalStorage());
660  EXPECT_TRUE(matches("void f() { int X; }", M));
661  EXPECT_TRUE(notMatches("int X;", M));
662  EXPECT_TRUE(notMatches("void f() { static int X; }", M));
663
664  M = varDecl(hasName("X"), hasGlobalStorage());
665  EXPECT_TRUE(notMatches("void f() { int X; }", M));
666  EXPECT_TRUE(matches("int X;", M));
667  EXPECT_TRUE(matches("void f() { static int X; }", M));
668}
669
670TEST(Matcher, VarDecl_StorageDuration) {
671  std::string T =
672    "void f() { int x; static int y; } int a;";
673
674  EXPECT_TRUE(matches(T, varDecl(hasName("x"), hasAutomaticStorageDuration())));
675  EXPECT_TRUE(
676    notMatches(T, varDecl(hasName("y"), hasAutomaticStorageDuration())));
677  EXPECT_TRUE(
678    notMatches(T, varDecl(hasName("a"), hasAutomaticStorageDuration())));
679
680  EXPECT_TRUE(matches(T, varDecl(hasName("y"), hasStaticStorageDuration())));
681  EXPECT_TRUE(matches(T, varDecl(hasName("a"), hasStaticStorageDuration())));
682  EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasStaticStorageDuration())));
683
684  // FIXME: It is really hard to test with thread_local itself because not all
685  // targets support TLS, which causes this to be an error depending on what
686  // platform the test is being run on. We do not have access to the TargetInfo
687  // object to be able to test whether the platform supports TLS or not.
688  EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasThreadStorageDuration())));
689  EXPECT_TRUE(notMatches(T, varDecl(hasName("y"), hasThreadStorageDuration())));
690  EXPECT_TRUE(notMatches(T, varDecl(hasName("a"), hasThreadStorageDuration())));
691}
692
693TEST(Matcher, FindsVarDeclInFunctionParameter) {
694  EXPECT_TRUE(matches(
695    "void f(int i) {}",
696    varDecl(hasName("i"))));
697}
698
699TEST(UnaryExpressionOrTypeTraitExpression, MatchesCorrectType) {
700  EXPECT_TRUE(matches("void x() { int a = sizeof(a); }", sizeOfExpr(
701    hasArgumentOfType(asString("int")))));
702  EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
703    hasArgumentOfType(asString("float")))));
704  EXPECT_TRUE(matches(
705    "struct A {}; void x() { A a; int b = sizeof(a); }",
706    sizeOfExpr(hasArgumentOfType(hasDeclaration(recordDecl(hasName("A")))))));
707  EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
708    hasArgumentOfType(hasDeclaration(recordDecl(hasName("string")))))));
709}
710
711TEST(IsInteger, MatchesIntegers) {
712  EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isInteger()))));
713  EXPECT_TRUE(matches(
714    "long long i = 0; void f(long long) { }; void g() {f(i);}",
715    callExpr(hasArgument(0, declRefExpr(
716      to(varDecl(hasType(isInteger()))))))));
717}
718
719TEST(IsInteger, ReportsNoFalsePositives) {
720  EXPECT_TRUE(notMatches("int *i;", varDecl(hasType(isInteger()))));
721  EXPECT_TRUE(notMatches("struct T {}; T t; void f(T *) { }; void g() {f(&t);}",
722                         callExpr(hasArgument(0, declRefExpr(
723                           to(varDecl(hasType(isInteger()))))))));
724}
725
726TEST(IsSignedInteger, MatchesSignedIntegers) {
727  EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isSignedInteger()))));
728  EXPECT_TRUE(notMatches("unsigned i = 0;",
729                         varDecl(hasType(isSignedInteger()))));
730}
731
732TEST(IsUnsignedInteger, MatchesUnsignedIntegers) {
733  EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isUnsignedInteger()))));
734  EXPECT_TRUE(matches("unsigned i = 0;",
735                      varDecl(hasType(isUnsignedInteger()))));
736}
737
738TEST(IsAnyPointer, MatchesPointers) {
739  EXPECT_TRUE(matches("int* i = nullptr;", varDecl(hasType(isAnyPointer()))));
740}
741
742TEST(IsAnyPointer, MatchesObjcPointer) {
743  EXPECT_TRUE(matchesObjC("@interface Foo @end Foo *f;",
744                          varDecl(hasType(isAnyPointer()))));
745}
746
747TEST(IsAnyPointer, ReportsNoFalsePositives) {
748  EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isAnyPointer()))));
749}
750
751TEST(IsAnyCharacter, MatchesCharacters) {
752  EXPECT_TRUE(matches("char i = 0;", varDecl(hasType(isAnyCharacter()))));
753}
754
755TEST(IsAnyCharacter, ReportsNoFalsePositives) {
756  EXPECT_TRUE(notMatches("int i;", varDecl(hasType(isAnyCharacter()))));
757}
758
759TEST(IsArrow, MatchesMemberVariablesViaArrow) {
760  EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
761                      memberExpr(isArrow())));
762  EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
763                      memberExpr(isArrow())));
764  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
765                         memberExpr(isArrow())));
766}
767
768TEST(IsArrow, MatchesStaticMemberVariablesViaArrow) {
769  EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
770                      memberExpr(isArrow())));
771  EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
772                         memberExpr(isArrow())));
773  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
774                         memberExpr(isArrow())));
775}
776
777TEST(IsArrow, MatchesMemberCallsViaArrow) {
778  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
779                      memberExpr(isArrow())));
780  EXPECT_TRUE(matches("class Y { void x() { x(); } };",
781                      memberExpr(isArrow())));
782  EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
783                         memberExpr(isArrow())));
784}
785
786TEST(ConversionDeclaration, IsExplicit) {
787  EXPECT_TRUE(matches("struct S { explicit operator int(); };",
788                      cxxConversionDecl(isExplicit())));
789  EXPECT_TRUE(notMatches("struct S { operator int(); };",
790                         cxxConversionDecl(isExplicit())));
791}
792
793TEST(Matcher, ArgumentCount) {
794  StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
795
796  EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
797  EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
798  EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
799}
800
801TEST(Matcher, ParameterCount) {
802  DeclarationMatcher Function1Arg = functionDecl(parameterCountIs(1));
803  EXPECT_TRUE(matches("void f(int i) {}", Function1Arg));
804  EXPECT_TRUE(matches("class X { void f(int i) {} };", Function1Arg));
805  EXPECT_TRUE(notMatches("void f() {}", Function1Arg));
806  EXPECT_TRUE(notMatches("void f(int i, int j, int k) {}", Function1Arg));
807  EXPECT_TRUE(matches("void f(int i, ...) {};", Function1Arg));
808}
809
810TEST(Matcher, References) {
811  DeclarationMatcher ReferenceClassX = varDecl(
812    hasType(references(recordDecl(hasName("X")))));
813  EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
814                      ReferenceClassX));
815  EXPECT_TRUE(
816    matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
817  // The match here is on the implicit copy constructor code for
818  // class X, not on code 'X x = y'.
819  EXPECT_TRUE(
820    matches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
821  EXPECT_TRUE(
822    notMatches("class X {}; extern X x;", ReferenceClassX));
823  EXPECT_TRUE(
824    notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
825}
826
827TEST(QualType, hasLocalQualifiers) {
828  EXPECT_TRUE(notMatches("typedef const int const_int; const_int i = 1;",
829                         varDecl(hasType(hasLocalQualifiers()))));
830  EXPECT_TRUE(matches("int *const j = nullptr;",
831                      varDecl(hasType(hasLocalQualifiers()))));
832  EXPECT_TRUE(matches("int *volatile k;",
833                      varDecl(hasType(hasLocalQualifiers()))));
834  EXPECT_TRUE(notMatches("int m;",
835                         varDecl(hasType(hasLocalQualifiers()))));
836}
837
838TEST(IsExternC, MatchesExternCFunctionDeclarations) {
839  EXPECT_TRUE(matches("extern \"C\" void f() {}", functionDecl(isExternC())));
840  EXPECT_TRUE(matches("extern \"C\" { void f() {} }",
841                      functionDecl(isExternC())));
842  EXPECT_TRUE(notMatches("void f() {}", functionDecl(isExternC())));
843}
844
845TEST(IsDefaulted, MatchesDefaultedFunctionDeclarations) {
846  EXPECT_TRUE(notMatches("class A { ~A(); };",
847                         functionDecl(hasName("~A"), isDefaulted())));
848  EXPECT_TRUE(matches("class B { ~B() = default; };",
849                      functionDecl(hasName("~B"), isDefaulted())));
850}
851
852TEST(IsDeleted, MatchesDeletedFunctionDeclarations) {
853  EXPECT_TRUE(
854    notMatches("void Func();", functionDecl(hasName("Func"), isDeleted())));
855  EXPECT_TRUE(matches("void Func() = delete;",
856                      functionDecl(hasName("Func"), isDeleted())));
857}
858
859TEST(IsNoThrow, MatchesNoThrowFunctionDeclarations) {
860  EXPECT_TRUE(notMatches("void f();", functionDecl(isNoThrow())));
861  EXPECT_TRUE(notMatches("void f() throw(int);", functionDecl(isNoThrow())));
862  EXPECT_TRUE(
863    notMatches("void f() noexcept(false);", functionDecl(isNoThrow())));
864  EXPECT_TRUE(matches("void f() throw();", functionDecl(isNoThrow())));
865  EXPECT_TRUE(matches("void f() noexcept;", functionDecl(isNoThrow())));
866
867  EXPECT_TRUE(notMatches("void f();", functionProtoType(isNoThrow())));
868  EXPECT_TRUE(notMatches("void f() throw(int);", functionProtoType(isNoThrow())));
869  EXPECT_TRUE(
870    notMatches("void f() noexcept(false);", functionProtoType(isNoThrow())));
871  EXPECT_TRUE(matches("void f() throw();", functionProtoType(isNoThrow())));
872  EXPECT_TRUE(matches("void f() noexcept;", functionProtoType(isNoThrow())));
873}
874
875TEST(isConstexpr, MatchesConstexprDeclarations) {
876  EXPECT_TRUE(matches("constexpr int foo = 42;",
877                      varDecl(hasName("foo"), isConstexpr())));
878  EXPECT_TRUE(matches("constexpr int bar();",
879                      functionDecl(hasName("bar"), isConstexpr())));
880}
881
882TEST(TemplateArgumentCountIs, Matches) {
883  EXPECT_TRUE(
884    matches("template<typename T> struct C {}; C<int> c;",
885            classTemplateSpecializationDecl(templateArgumentCountIs(1))));
886  EXPECT_TRUE(
887    notMatches("template<typename T> struct C {}; C<int> c;",
888               classTemplateSpecializationDecl(templateArgumentCountIs(2))));
889
890  EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
891                      templateSpecializationType(templateArgumentCountIs(1))));
892  EXPECT_TRUE(
893    notMatches("template<typename T> struct C {}; C<int> c;",
894               templateSpecializationType(templateArgumentCountIs(2))));
895}
896
897TEST(IsIntegral, Matches) {
898  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
899                      classTemplateSpecializationDecl(
900                        hasAnyTemplateArgument(isIntegral()))));
901  EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
902                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
903                           templateArgument(isIntegral())))));
904}
905
906TEST(EqualsIntegralValue, Matches) {
907  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
908                      classTemplateSpecializationDecl(
909                        hasAnyTemplateArgument(equalsIntegralValue("42")))));
910  EXPECT_TRUE(matches("template<int T> struct C {}; C<-42> c;",
911                      classTemplateSpecializationDecl(
912                        hasAnyTemplateArgument(equalsIntegralValue("-42")))));
913  EXPECT_TRUE(matches("template<int T> struct C {}; C<-0042> c;",
914                      classTemplateSpecializationDecl(
915                        hasAnyTemplateArgument(equalsIntegralValue("-34")))));
916  EXPECT_TRUE(notMatches("template<int T> struct C {}; C<42> c;",
917                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
918                           equalsIntegralValue("0042")))));
919}
920
921TEST(Matcher, MatchesAccessSpecDecls) {
922  EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));
923  EXPECT_TRUE(
924      matches("class C { public: int i; };", accessSpecDecl(isPublic())));
925  EXPECT_TRUE(
926      notMatches("class C { public: int i; };", accessSpecDecl(isProtected())));
927  EXPECT_TRUE(
928      notMatches("class C { public: int i; };", accessSpecDecl(isPrivate())));
929
930  EXPECT_TRUE(notMatches("class C { int i; };", accessSpecDecl()));
931}
932
933TEST(Matcher, MatchesFinal) {
934  EXPECT_TRUE(matches("class X final {};", cxxRecordDecl(isFinal())));
935  EXPECT_TRUE(matches("class X { virtual void f() final; };",
936                      cxxMethodDecl(isFinal())));
937  EXPECT_TRUE(notMatches("class X {};", cxxRecordDecl(isFinal())));
938  EXPECT_TRUE(
939    notMatches("class X { virtual void f(); };", cxxMethodDecl(isFinal())));
940}
941
942TEST(Matcher, MatchesVirtualMethod) {
943  EXPECT_TRUE(matches("class X { virtual int f(); };",
944                      cxxMethodDecl(isVirtual(), hasName("::X::f"))));
945  EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isVirtual())));
946}
947
948TEST(Matcher, MatchesVirtualAsWrittenMethod) {
949  EXPECT_TRUE(matches("class A { virtual int f(); };"
950                        "class B : public A { int f(); };",
951                      cxxMethodDecl(isVirtualAsWritten(), hasName("::A::f"))));
952  EXPECT_TRUE(
953    notMatches("class A { virtual int f(); };"
954                 "class B : public A { int f(); };",
955               cxxMethodDecl(isVirtualAsWritten(), hasName("::B::f"))));
956}
957
958TEST(Matcher, MatchesPureMethod) {
959  EXPECT_TRUE(matches("class X { virtual int f() = 0; };",
960                      cxxMethodDecl(isPure(), hasName("::X::f"))));
961  EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isPure())));
962}
963
964TEST(Matcher, MatchesCopyAssignmentOperator) {
965  EXPECT_TRUE(matches("class X { X &operator=(X); };",
966                      cxxMethodDecl(isCopyAssignmentOperator())));
967  EXPECT_TRUE(matches("class X { X &operator=(X &); };",
968                      cxxMethodDecl(isCopyAssignmentOperator())));
969  EXPECT_TRUE(matches("class X { X &operator=(const X &); };",
970                      cxxMethodDecl(isCopyAssignmentOperator())));
971  EXPECT_TRUE(matches("class X { X &operator=(volatile X &); };",
972                      cxxMethodDecl(isCopyAssignmentOperator())));
973  EXPECT_TRUE(matches("class X { X &operator=(const volatile X &); };",
974                      cxxMethodDecl(isCopyAssignmentOperator())));
975  EXPECT_TRUE(notMatches("class X { X &operator=(X &&); };",
976                         cxxMethodDecl(isCopyAssignmentOperator())));
977}
978
979TEST(Matcher, MatchesMoveAssignmentOperator) {
980  EXPECT_TRUE(notMatches("class X { X &operator=(X); };",
981                         cxxMethodDecl(isMoveAssignmentOperator())));
982  EXPECT_TRUE(matches("class X { X &operator=(X &&); };",
983                      cxxMethodDecl(isMoveAssignmentOperator())));
984  EXPECT_TRUE(matches("class X { X &operator=(const X &&); };",
985                      cxxMethodDecl(isMoveAssignmentOperator())));
986  EXPECT_TRUE(matches("class X { X &operator=(volatile X &&); };",
987                      cxxMethodDecl(isMoveAssignmentOperator())));
988  EXPECT_TRUE(matches("class X { X &operator=(const volatile X &&); };",
989                      cxxMethodDecl(isMoveAssignmentOperator())));
990  EXPECT_TRUE(notMatches("class X { X &operator=(X &); };",
991                         cxxMethodDecl(isMoveAssignmentOperator())));
992}
993
994TEST(Matcher, MatchesConstMethod) {
995  EXPECT_TRUE(
996    matches("struct A { void foo() const; };", cxxMethodDecl(isConst())));
997  EXPECT_TRUE(
998    notMatches("struct A { void foo(); };", cxxMethodDecl(isConst())));
999}
1000
1001TEST(Matcher, MatchesOverridingMethod) {
1002  EXPECT_TRUE(matches("class X { virtual int f(); }; "
1003                        "class Y : public X { int f(); };",
1004                      cxxMethodDecl(isOverride(), hasName("::Y::f"))));
1005  EXPECT_TRUE(notMatches("class X { virtual int f(); }; "
1006                           "class Y : public X { int f(); };",
1007                         cxxMethodDecl(isOverride(), hasName("::X::f"))));
1008  EXPECT_TRUE(notMatches("class X { int f(); }; "
1009                           "class Y : public X { int f(); };",
1010                         cxxMethodDecl(isOverride())));
1011  EXPECT_TRUE(notMatches("class X { int f(); int f(int); }; ",
1012                         cxxMethodDecl(isOverride())));
1013  EXPECT_TRUE(
1014    matches("template <typename Base> struct Y : Base { void f() override;};",
1015            cxxMethodDecl(isOverride(), hasName("::Y::f"))));
1016}
1017
1018TEST(Matcher, ConstructorArgument) {
1019  StatementMatcher Constructor = cxxConstructExpr(
1020    hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
1021
1022  EXPECT_TRUE(
1023    matches("class X { public: X(int); }; void x() { int y; X x(y); }",
1024            Constructor));
1025  EXPECT_TRUE(
1026    matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
1027            Constructor));
1028  EXPECT_TRUE(
1029    matches("class X { public: X(int); }; void x() { int y; X x = y; }",
1030            Constructor));
1031  EXPECT_TRUE(
1032    notMatches("class X { public: X(int); }; void x() { int z; X x(z); }",
1033               Constructor));
1034
1035  StatementMatcher WrongIndex = cxxConstructExpr(
1036    hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
1037  EXPECT_TRUE(
1038    notMatches("class X { public: X(int); }; void x() { int y; X x(y); }",
1039               WrongIndex));
1040}
1041
1042TEST(Matcher, ConstructorArgumentCount) {
1043  StatementMatcher Constructor1Arg = cxxConstructExpr(argumentCountIs(1));
1044
1045  EXPECT_TRUE(
1046    matches("class X { public: X(int); }; void x() { X x(0); }",
1047            Constructor1Arg));
1048  EXPECT_TRUE(
1049    matches("class X { public: X(int); }; void x() { X x = X(0); }",
1050            Constructor1Arg));
1051  EXPECT_TRUE(
1052    matches("class X { public: X(int); }; void x() { X x = 0; }",
1053            Constructor1Arg));
1054  EXPECT_TRUE(
1055    notMatches("class X { public: X(int, int); }; void x() { X x(0, 0); }",
1056               Constructor1Arg));
1057}
1058
1059TEST(Matcher, ConstructorListInitialization) {
1060  StatementMatcher ConstructorListInit =
1061    cxxConstructExpr(isListInitialization());
1062
1063  EXPECT_TRUE(
1064    matches("class X { public: X(int); }; void x() { X x{0}; }",
1065            ConstructorListInit));
1066  EXPECT_FALSE(
1067    matches("class X { public: X(int); }; void x() { X x(0); }",
1068            ConstructorListInit));
1069}
1070
1071TEST(ConstructorDeclaration, IsImplicit) {
1072  // This one doesn't match because the constructor is not added by the
1073  // compiler (it is not needed).
1074  EXPECT_TRUE(notMatches("class Foo { };",
1075                         cxxConstructorDecl(isImplicit())));
1076  // The compiler added the implicit default constructor.
1077  EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
1078                      cxxConstructorDecl(isImplicit())));
1079  EXPECT_TRUE(matches("class Foo { Foo(){} };",
1080                      cxxConstructorDecl(unless(isImplicit()))));
1081  // The compiler added an implicit assignment operator.
1082  EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
1083                      cxxMethodDecl(isImplicit(), hasName("operator="))));
1084}
1085
1086TEST(ConstructorDeclaration, IsExplicit) {
1087  EXPECT_TRUE(matches("struct S { explicit S(int); };",
1088                      cxxConstructorDecl(isExplicit())));
1089  EXPECT_TRUE(notMatches("struct S { S(int); };",
1090                         cxxConstructorDecl(isExplicit())));
1091}
1092
1093TEST(ConstructorDeclaration, Kinds) {
1094  EXPECT_TRUE(matches("struct S { S(); };",
1095                      cxxConstructorDecl(isDefaultConstructor())));
1096  EXPECT_TRUE(notMatches("struct S { S(); };",
1097                         cxxConstructorDecl(isCopyConstructor())));
1098  EXPECT_TRUE(notMatches("struct S { S(); };",
1099                         cxxConstructorDecl(isMoveConstructor())));
1100
1101  EXPECT_TRUE(notMatches("struct S { S(const S&); };",
1102                         cxxConstructorDecl(isDefaultConstructor())));
1103  EXPECT_TRUE(matches("struct S { S(const S&); };",
1104                      cxxConstructorDecl(isCopyConstructor())));
1105  EXPECT_TRUE(notMatches("struct S { S(const S&); };",
1106                         cxxConstructorDecl(isMoveConstructor())));
1107
1108  EXPECT_TRUE(notMatches("struct S { S(S&&); };",
1109                         cxxConstructorDecl(isDefaultConstructor())));
1110  EXPECT_TRUE(notMatches("struct S { S(S&&); };",
1111                         cxxConstructorDecl(isCopyConstructor())));
1112  EXPECT_TRUE(matches("struct S { S(S&&); };",
1113                      cxxConstructorDecl(isMoveConstructor())));
1114}
1115
1116TEST(ConstructorDeclaration, IsUserProvided) {
1117  EXPECT_TRUE(notMatches("struct S { int X = 0; };",
1118                         cxxConstructorDecl(isUserProvided())));
1119  EXPECT_TRUE(notMatches("struct S { S() = default; };",
1120                         cxxConstructorDecl(isUserProvided())));
1121  EXPECT_TRUE(notMatches("struct S { S() = delete; };",
1122                         cxxConstructorDecl(isUserProvided())));
1123  EXPECT_TRUE(
1124    matches("struct S { S(); };", cxxConstructorDecl(isUserProvided())));
1125  EXPECT_TRUE(matches("struct S { S(); }; S::S(){}",
1126                      cxxConstructorDecl(isUserProvided())));
1127}
1128
1129TEST(ConstructorDeclaration, IsDelegatingConstructor) {
1130  EXPECT_TRUE(notMatches("struct S { S(); S(int); int X; };",
1131                         cxxConstructorDecl(isDelegatingConstructor())));
1132  EXPECT_TRUE(notMatches("struct S { S(){} S(int X) : X(X) {} int X; };",
1133                         cxxConstructorDecl(isDelegatingConstructor())));
1134  EXPECT_TRUE(matches(
1135    "struct S { S() : S(0) {} S(int X) : X(X) {} int X; };",
1136    cxxConstructorDecl(isDelegatingConstructor(), parameterCountIs(0))));
1137  EXPECT_TRUE(matches(
1138    "struct S { S(); S(int X); int X; }; S::S(int X) : S() {}",
1139    cxxConstructorDecl(isDelegatingConstructor(), parameterCountIs(1))));
1140}
1141
1142TEST(StringLiteral, HasSize) {
1143  StatementMatcher Literal = stringLiteral(hasSize(4));
1144  EXPECT_TRUE(matches("const char *s = \"abcd\";", Literal));
1145  // wide string
1146  EXPECT_TRUE(matches("const wchar_t *s = L\"abcd\";", Literal));
1147  // with escaped characters
1148  EXPECT_TRUE(matches("const char *s = \"\x05\x06\x07\x08\";", Literal));
1149  // no matching, too small
1150  EXPECT_TRUE(notMatches("const char *s = \"ab\";", Literal));
1151}
1152
1153TEST(Matcher, HasNameSupportsNamespaces) {
1154  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1155                      recordDecl(hasName("a::b::C"))));
1156  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1157                      recordDecl(hasName("::a::b::C"))));
1158  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1159                      recordDecl(hasName("b::C"))));
1160  EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1161                      recordDecl(hasName("C"))));
1162  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1163                         recordDecl(hasName("c::b::C"))));
1164  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1165                         recordDecl(hasName("a::c::C"))));
1166  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1167                         recordDecl(hasName("a::b::A"))));
1168  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1169                         recordDecl(hasName("::C"))));
1170  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1171                         recordDecl(hasName("::b::C"))));
1172  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1173                         recordDecl(hasName("z::a::b::C"))));
1174  EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1175                         recordDecl(hasName("a+b::C"))));
1176  EXPECT_TRUE(notMatches("namespace a { namespace b { class AC; } }",
1177                         recordDecl(hasName("C"))));
1178}
1179
1180TEST(Matcher, HasNameSupportsOuterClasses) {
1181  EXPECT_TRUE(
1182    matches("class A { class B { class C; }; };",
1183            recordDecl(hasName("A::B::C"))));
1184  EXPECT_TRUE(
1185    matches("class A { class B { class C; }; };",
1186            recordDecl(hasName("::A::B::C"))));
1187  EXPECT_TRUE(
1188    matches("class A { class B { class C; }; };",
1189            recordDecl(hasName("B::C"))));
1190  EXPECT_TRUE(
1191    matches("class A { class B { class C; }; };",
1192            recordDecl(hasName("C"))));
1193  EXPECT_TRUE(
1194    notMatches("class A { class B { class C; }; };",
1195               recordDecl(hasName("c::B::C"))));
1196  EXPECT_TRUE(
1197    notMatches("class A { class B { class C; }; };",
1198               recordDecl(hasName("A::c::C"))));
1199  EXPECT_TRUE(
1200    notMatches("class A { class B { class C; }; };",
1201               recordDecl(hasName("A::B::A"))));
1202  EXPECT_TRUE(
1203    notMatches("class A { class B { class C; }; };",
1204               recordDecl(hasName("::C"))));
1205  EXPECT_TRUE(
1206    notMatches("class A { class B { class C; }; };",
1207               recordDecl(hasName("::B::C"))));
1208  EXPECT_TRUE(notMatches("class A { class B { class C; }; };",
1209                         recordDecl(hasName("z::A::B::C"))));
1210  EXPECT_TRUE(
1211    notMatches("class A { class B { class C; }; };",
1212               recordDecl(hasName("A+B::C"))));
1213}
1214
1215TEST(Matcher, HasNameSupportsInlinedNamespaces) {
1216  std::string code = "namespace a { inline namespace b { class C; } }";
1217  EXPECT_TRUE(matches(code, recordDecl(hasName("a::b::C"))));
1218  EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1219  EXPECT_TRUE(matches(code, recordDecl(hasName("::a::b::C"))));
1220  EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1221}
1222
1223TEST(Matcher, HasNameSupportsAnonymousNamespaces) {
1224  std::string code = "namespace a { namespace { class C; } }";
1225  EXPECT_TRUE(
1226    matches(code, recordDecl(hasName("a::(anonymous namespace)::C"))));
1227  EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1228  EXPECT_TRUE(
1229    matches(code, recordDecl(hasName("::a::(anonymous namespace)::C"))));
1230  EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1231}
1232
1233TEST(Matcher, HasNameSupportsAnonymousOuterClasses) {
1234  EXPECT_TRUE(matches("class A { class { class C; } x; };",
1235                      recordDecl(hasName("A::(anonymous class)::C"))));
1236  EXPECT_TRUE(matches("class A { class { class C; } x; };",
1237                      recordDecl(hasName("::A::(anonymous class)::C"))));
1238  EXPECT_FALSE(matches("class A { class { class C; } x; };",
1239                       recordDecl(hasName("::A::C"))));
1240  EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1241                      recordDecl(hasName("A::(anonymous struct)::C"))));
1242  EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1243                      recordDecl(hasName("::A::(anonymous struct)::C"))));
1244  EXPECT_FALSE(matches("class A { struct { class C; } x; };",
1245                       recordDecl(hasName("::A::C"))));
1246}
1247
1248TEST(Matcher, HasNameSupportsFunctionScope) {
1249  std::string code =
1250    "namespace a { void F(int a) { struct S { int m; }; int i; } }";
1251  EXPECT_TRUE(matches(code, varDecl(hasName("i"))));
1252  EXPECT_FALSE(matches(code, varDecl(hasName("F()::i"))));
1253
1254  EXPECT_TRUE(matches(code, fieldDecl(hasName("m"))));
1255  EXPECT_TRUE(matches(code, fieldDecl(hasName("S::m"))));
1256  EXPECT_TRUE(matches(code, fieldDecl(hasName("F(int)::S::m"))));
1257  EXPECT_TRUE(matches(code, fieldDecl(hasName("a::F(int)::S::m"))));
1258  EXPECT_TRUE(matches(code, fieldDecl(hasName("::a::F(int)::S::m"))));
1259}
1260
1261TEST(Matcher, HasAnyName) {
1262  const std::string Code = "namespace a { namespace b { class C; } }";
1263
1264  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "a::b::C"))));
1265  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("a::b::C", "XX"))));
1266  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX::C", "a::b::C"))));
1267  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "C"))));
1268
1269  EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
1270  EXPECT_TRUE(
1271    matches(Code, recordDecl(hasAnyName("::C", "::b::C", "::a::b::C"))));
1272
1273  std::vector<StringRef> Names = {"::C", "::b::C", "::a::b::C"};
1274  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName(Names))));
1275}
1276
1277TEST(Matcher, IsDefinition) {
1278  DeclarationMatcher DefinitionOfClassA =
1279    recordDecl(hasName("A"), isDefinition());
1280  EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
1281  EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
1282
1283  DeclarationMatcher DefinitionOfVariableA =
1284    varDecl(hasName("a"), isDefinition());
1285  EXPECT_TRUE(matches("int a;", DefinitionOfVariableA));
1286  EXPECT_TRUE(notMatches("extern int a;", DefinitionOfVariableA));
1287
1288  DeclarationMatcher DefinitionOfMethodA =
1289    cxxMethodDecl(hasName("a"), isDefinition());
1290  EXPECT_TRUE(matches("class A { void a() {} };", DefinitionOfMethodA));
1291  EXPECT_TRUE(notMatches("class A { void a(); };", DefinitionOfMethodA));
1292}
1293
1294TEST(Matcher, HandlesNullQualTypes) {
1295  // FIXME: Add a Type matcher so we can replace uses of this
1296  // variable with Type(True())
1297  const TypeMatcher AnyType = anything();
1298
1299  // We don't really care whether this matcher succeeds; we're testing that
1300  // it completes without crashing.
1301  EXPECT_TRUE(matches(
1302    "struct A { };"
1303      "template <typename T>"
1304      "void f(T t) {"
1305      "  T local_t(t /* this becomes a null QualType in the AST */);"
1306      "}"
1307      "void g() {"
1308      "  f(0);"
1309      "}",
1310    expr(hasType(TypeMatcher(
1311      anyOf(
1312        TypeMatcher(hasDeclaration(anything())),
1313        pointsTo(AnyType),
1314        references(AnyType)
1315        // Other QualType matchers should go here.
1316      ))))));
1317}
1318
1319
1320TEST(StatementCountIs, FindsNoStatementsInAnEmptyCompoundStatement) {
1321  EXPECT_TRUE(matches("void f() { }",
1322                      compoundStmt(statementCountIs(0))));
1323  EXPECT_TRUE(notMatches("void f() {}",
1324                         compoundStmt(statementCountIs(1))));
1325}
1326
1327TEST(StatementCountIs, AppearsToMatchOnlyOneCount) {
1328  EXPECT_TRUE(matches("void f() { 1; }",
1329                      compoundStmt(statementCountIs(1))));
1330  EXPECT_TRUE(notMatches("void f() { 1; }",
1331                         compoundStmt(statementCountIs(0))));
1332  EXPECT_TRUE(notMatches("void f() { 1; }",
1333                         compoundStmt(statementCountIs(2))));
1334}
1335
1336TEST(StatementCountIs, WorksWithMultipleStatements) {
1337  EXPECT_TRUE(matches("void f() { 1; 2; 3; }",
1338                      compoundStmt(statementCountIs(3))));
1339}
1340
1341TEST(StatementCountIs, WorksWithNestedCompoundStatements) {
1342  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1343                      compoundStmt(statementCountIs(1))));
1344  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1345                      compoundStmt(statementCountIs(2))));
1346  EXPECT_TRUE(notMatches("void f() { { 1; } { 1; 2; 3; 4; } }",
1347                         compoundStmt(statementCountIs(3))));
1348  EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1349                      compoundStmt(statementCountIs(4))));
1350}
1351
1352TEST(Member, WorksInSimplestCase) {
1353  EXPECT_TRUE(matches("struct { int first; } s; int i(s.first);",
1354                      memberExpr(member(hasName("first")))));
1355}
1356
1357TEST(Member, DoesNotMatchTheBaseExpression) {
1358  // Don't pick out the wrong part of the member expression, this should
1359  // be checking the member (name) only.
1360  EXPECT_TRUE(notMatches("struct { int i; } first; int i(first.i);",
1361                         memberExpr(member(hasName("first")))));
1362}
1363
1364TEST(Member, MatchesInMemberFunctionCall) {
1365  EXPECT_TRUE(matches("void f() {"
1366                        "  struct { void first() {}; } s;"
1367                        "  s.first();"
1368                        "};",
1369                      memberExpr(member(hasName("first")))));
1370}
1371
1372TEST(Member, MatchesMember) {
1373  EXPECT_TRUE(matches(
1374    "struct A { int i; }; void f() { A a; a.i = 2; }",
1375    memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
1376  EXPECT_TRUE(notMatches(
1377    "struct A { float f; }; void f() { A a; a.f = 2.0f; }",
1378    memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
1379}
1380
1381TEST(Member, BitFields) {
1382  EXPECT_TRUE(matches("class C { int a : 2; int b; };",
1383                      fieldDecl(isBitField(), hasName("a"))));
1384  EXPECT_TRUE(notMatches("class C { int a : 2; int b; };",
1385                         fieldDecl(isBitField(), hasName("b"))));
1386  EXPECT_TRUE(matches("class C { int a : 2; int b : 4; };",
1387                      fieldDecl(isBitField(), hasBitWidth(2), hasName("a"))));
1388}
1389
1390TEST(Member, UnderstandsAccess) {
1391  EXPECT_TRUE(matches(
1392    "struct A { int i; };", fieldDecl(isPublic(), hasName("i"))));
1393  EXPECT_TRUE(notMatches(
1394    "struct A { int i; };", fieldDecl(isProtected(), hasName("i"))));
1395  EXPECT_TRUE(notMatches(
1396    "struct A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
1397
1398  EXPECT_TRUE(notMatches(
1399    "class A { int i; };", fieldDecl(isPublic(), hasName("i"))));
1400  EXPECT_TRUE(notMatches(
1401    "class A { int i; };", fieldDecl(isProtected(), hasName("i"))));
1402  EXPECT_TRUE(matches(
1403    "class A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
1404
1405  EXPECT_TRUE(notMatches(
1406    "class A { protected: int i; };", fieldDecl(isPublic(), hasName("i"))));
1407  EXPECT_TRUE(matches("class A { protected: int i; };",
1408                      fieldDecl(isProtected(), hasName("i"))));
1409  EXPECT_TRUE(notMatches(
1410    "class A { protected: int i; };", fieldDecl(isPrivate(), hasName("i"))));
1411
1412  // Non-member decls have the AccessSpecifier AS_none and thus aren't matched.
1413  EXPECT_TRUE(notMatches("int i;", varDecl(isPublic(), hasName("i"))));
1414  EXPECT_TRUE(notMatches("int i;", varDecl(isProtected(), hasName("i"))));
1415  EXPECT_TRUE(notMatches("int i;", varDecl(isPrivate(), hasName("i"))));
1416}
1417
1418TEST(hasDynamicExceptionSpec, MatchesDynamicExceptionSpecifications) {
1419  EXPECT_TRUE(notMatches("void f();", functionDecl(hasDynamicExceptionSpec())));
1420  EXPECT_TRUE(notMatches("void g() noexcept;",
1421                         functionDecl(hasDynamicExceptionSpec())));
1422  EXPECT_TRUE(notMatches("void h() noexcept(true);",
1423                         functionDecl(hasDynamicExceptionSpec())));
1424  EXPECT_TRUE(notMatches("void i() noexcept(false);",
1425                         functionDecl(hasDynamicExceptionSpec())));
1426  EXPECT_TRUE(
1427      matches("void j() throw();", functionDecl(hasDynamicExceptionSpec())));
1428  EXPECT_TRUE(
1429      matches("void k() throw(int);", functionDecl(hasDynamicExceptionSpec())));
1430  EXPECT_TRUE(
1431      matches("void l() throw(...);", functionDecl(hasDynamicExceptionSpec())));
1432
1433  EXPECT_TRUE(notMatches("void f();", functionProtoType(hasDynamicExceptionSpec())));
1434  EXPECT_TRUE(notMatches("void g() noexcept;",
1435                         functionProtoType(hasDynamicExceptionSpec())));
1436  EXPECT_TRUE(notMatches("void h() noexcept(true);",
1437                         functionProtoType(hasDynamicExceptionSpec())));
1438  EXPECT_TRUE(notMatches("void i() noexcept(false);",
1439                         functionProtoType(hasDynamicExceptionSpec())));
1440  EXPECT_TRUE(
1441      matches("void j() throw();", functionProtoType(hasDynamicExceptionSpec())));
1442  EXPECT_TRUE(
1443      matches("void k() throw(int);", functionProtoType(hasDynamicExceptionSpec())));
1444  EXPECT_TRUE(
1445      matches("void l() throw(...);", functionProtoType(hasDynamicExceptionSpec())));
1446}
1447
1448TEST(HasObjectExpression, DoesNotMatchMember) {
1449  EXPECT_TRUE(notMatches(
1450    "class X {}; struct Z { X m; }; void f(Z z) { z.m; }",
1451    memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
1452}
1453
1454TEST(HasObjectExpression, MatchesBaseOfVariable) {
1455  EXPECT_TRUE(matches(
1456    "struct X { int m; }; void f(X x) { x.m; }",
1457    memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
1458  EXPECT_TRUE(matches(
1459    "struct X { int m; }; void f(X* x) { x->m; }",
1460    memberExpr(hasObjectExpression(
1461      hasType(pointsTo(recordDecl(hasName("X"))))))));
1462}
1463
1464TEST(HasObjectExpression,
1465     MatchesObjectExpressionOfImplicitlyFormedMemberExpression) {
1466  EXPECT_TRUE(matches(
1467    "class X {}; struct S { X m; void f() { this->m; } };",
1468    memberExpr(hasObjectExpression(
1469      hasType(pointsTo(recordDecl(hasName("S"))))))));
1470  EXPECT_TRUE(matches(
1471    "class X {}; struct S { X m; void f() { m; } };",
1472    memberExpr(hasObjectExpression(
1473      hasType(pointsTo(recordDecl(hasName("S"))))))));
1474}
1475
1476TEST(Field, DoesNotMatchNonFieldMembers) {
1477  EXPECT_TRUE(notMatches("class X { void m(); };", fieldDecl(hasName("m"))));
1478  EXPECT_TRUE(notMatches("class X { class m {}; };", fieldDecl(hasName("m"))));
1479  EXPECT_TRUE(notMatches("class X { enum { m }; };", fieldDecl(hasName("m"))));
1480  EXPECT_TRUE(notMatches("class X { enum m {}; };", fieldDecl(hasName("m"))));
1481}
1482
1483TEST(Field, MatchesField) {
1484  EXPECT_TRUE(matches("class X { int m; };", fieldDecl(hasName("m"))));
1485}
1486
1487TEST(IsVolatileQualified, QualifiersMatch) {
1488  EXPECT_TRUE(matches("volatile int i = 42;",
1489                      varDecl(hasType(isVolatileQualified()))));
1490  EXPECT_TRUE(notMatches("volatile int *i;",
1491                         varDecl(hasType(isVolatileQualified()))));
1492  EXPECT_TRUE(matches("typedef volatile int v_int; v_int i = 42;",
1493                      varDecl(hasType(isVolatileQualified()))));
1494}
1495
1496TEST(IsConstQualified, MatchesConstInt) {
1497  EXPECT_TRUE(matches("const int i = 42;",
1498                      varDecl(hasType(isConstQualified()))));
1499}
1500
1501TEST(IsConstQualified, MatchesConstPointer) {
1502  EXPECT_TRUE(matches("int i = 42; int* const p(&i);",
1503                      varDecl(hasType(isConstQualified()))));
1504}
1505
1506TEST(IsConstQualified, MatchesThroughTypedef) {
1507  EXPECT_TRUE(matches("typedef const int const_int; const_int i = 42;",
1508                      varDecl(hasType(isConstQualified()))));
1509  EXPECT_TRUE(matches("typedef int* int_ptr; const int_ptr p(0);",
1510                      varDecl(hasType(isConstQualified()))));
1511}
1512
1513TEST(IsConstQualified, DoesNotMatchInappropriately) {
1514  EXPECT_TRUE(notMatches("typedef int nonconst_int; nonconst_int i = 42;",
1515                         varDecl(hasType(isConstQualified()))));
1516  EXPECT_TRUE(notMatches("int const* p;",
1517                         varDecl(hasType(isConstQualified()))));
1518}
1519
1520TEST(DeclCount, DeclCountIsCorrect) {
1521  EXPECT_TRUE(matches("void f() {int i,j;}",
1522                      declStmt(declCountIs(2))));
1523  EXPECT_TRUE(notMatches("void f() {int i,j; int k;}",
1524                         declStmt(declCountIs(3))));
1525  EXPECT_TRUE(notMatches("void f() {int i,j, k, l;}",
1526                         declStmt(declCountIs(3))));
1527}
1528
1529
1530TEST(EachOf, TriggersForEachMatch) {
1531  EXPECT_TRUE(matchAndVerifyResultTrue(
1532    "class A { int a; int b; };",
1533    recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1534                      has(fieldDecl(hasName("b")).bind("v")))),
1535    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
1536}
1537
1538TEST(EachOf, BehavesLikeAnyOfUnlessBothMatch) {
1539  EXPECT_TRUE(matchAndVerifyResultTrue(
1540    "class A { int a; int c; };",
1541    recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1542                      has(fieldDecl(hasName("b")).bind("v")))),
1543    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
1544  EXPECT_TRUE(matchAndVerifyResultTrue(
1545    "class A { int c; int b; };",
1546    recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1547                      has(fieldDecl(hasName("b")).bind("v")))),
1548    llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
1549  EXPECT_TRUE(notMatches(
1550    "class A { int c; int d; };",
1551    recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1552                      has(fieldDecl(hasName("b")).bind("v"))))));
1553}
1554
1555TEST(IsTemplateInstantiation, MatchesImplicitClassTemplateInstantiation) {
1556  // Make sure that we can both match the class by name (::X) and by the type
1557  // the template was instantiated with (via a field).
1558
1559  EXPECT_TRUE(matches(
1560    "template <typename T> class X {}; class A {}; X<A> x;",
1561    cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1562
1563  EXPECT_TRUE(matches(
1564    "template <typename T> class X { T t; }; class A {}; X<A> x;",
1565    cxxRecordDecl(isTemplateInstantiation(), hasDescendant(
1566      fieldDecl(hasType(recordDecl(hasName("A"))))))));
1567}
1568
1569TEST(IsTemplateInstantiation, MatchesImplicitFunctionTemplateInstantiation) {
1570  EXPECT_TRUE(matches(
1571    "template <typename T> void f(T t) {} class A {}; void g() { f(A()); }",
1572    functionDecl(hasParameter(0, hasType(recordDecl(hasName("A")))),
1573                 isTemplateInstantiation())));
1574}
1575
1576TEST(IsTemplateInstantiation, MatchesExplicitClassTemplateInstantiation) {
1577  EXPECT_TRUE(matches(
1578    "template <typename T> class X { T t; }; class A {};"
1579      "template class X<A>;",
1580    cxxRecordDecl(isTemplateInstantiation(), hasDescendant(
1581      fieldDecl(hasType(recordDecl(hasName("A"))))))));
1582}
1583
1584TEST(IsTemplateInstantiation,
1585     MatchesInstantiationOfPartiallySpecializedClassTemplate) {
1586  EXPECT_TRUE(matches(
1587    "template <typename T> class X {};"
1588      "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
1589    cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1590}
1591
1592TEST(IsTemplateInstantiation,
1593     MatchesInstantiationOfClassTemplateNestedInNonTemplate) {
1594  EXPECT_TRUE(matches(
1595    "class A {};"
1596      "class X {"
1597      "  template <typename U> class Y { U u; };"
1598      "  Y<A> y;"
1599      "};",
1600    cxxRecordDecl(hasName("::X::Y"), isTemplateInstantiation())));
1601}
1602
1603TEST(IsTemplateInstantiation, DoesNotMatchInstantiationsInsideOfInstantiation) {
1604  // FIXME: Figure out whether this makes sense. It doesn't affect the
1605  // normal use case as long as the uppermost instantiation always is marked
1606  // as template instantiation, but it might be confusing as a predicate.
1607  EXPECT_TRUE(matches(
1608    "class A {};"
1609      "template <typename T> class X {"
1610      "  template <typename U> class Y { U u; };"
1611      "  Y<T> y;"
1612      "}; X<A> x;",
1613    cxxRecordDecl(hasName("::X<A>::Y"), unless(isTemplateInstantiation()))));
1614}
1615
1616TEST(IsTemplateInstantiation, DoesNotMatchExplicitClassTemplateSpecialization) {
1617  EXPECT_TRUE(notMatches(
1618    "template <typename T> class X {}; class A {};"
1619      "template <> class X<A> {}; X<A> x;",
1620    cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1621}
1622
1623TEST(IsTemplateInstantiation, DoesNotMatchNonTemplate) {
1624  EXPECT_TRUE(notMatches(
1625    "class A {}; class Y { A a; };",
1626    cxxRecordDecl(isTemplateInstantiation())));
1627}
1628
1629TEST(IsInstantiated, MatchesInstantiation) {
1630  EXPECT_TRUE(
1631    matches("template<typename T> class A { T i; }; class Y { A<int> a; };",
1632            cxxRecordDecl(isInstantiated())));
1633}
1634
1635TEST(IsInstantiated, NotMatchesDefinition) {
1636  EXPECT_TRUE(notMatches("template<typename T> class A { T i; };",
1637                         cxxRecordDecl(isInstantiated())));
1638}
1639
1640TEST(IsInTemplateInstantiation, MatchesInstantiationStmt) {
1641  EXPECT_TRUE(matches("template<typename T> struct A { A() { T i; } };"
1642                        "class Y { A<int> a; }; Y y;",
1643                      declStmt(isInTemplateInstantiation())));
1644}
1645
1646TEST(IsInTemplateInstantiation, NotMatchesDefinitionStmt) {
1647  EXPECT_TRUE(notMatches("template<typename T> struct A { void x() { T i; } };",
1648                         declStmt(isInTemplateInstantiation())));
1649}
1650
1651TEST(IsInstantiated, MatchesFunctionInstantiation) {
1652  EXPECT_TRUE(
1653    matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
1654            functionDecl(isInstantiated())));
1655}
1656
1657TEST(IsInstantiated, NotMatchesFunctionDefinition) {
1658  EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1659                         varDecl(isInstantiated())));
1660}
1661
1662TEST(IsInTemplateInstantiation, MatchesFunctionInstantiationStmt) {
1663  EXPECT_TRUE(
1664    matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
1665            declStmt(isInTemplateInstantiation())));
1666}
1667
1668TEST(IsInTemplateInstantiation, NotMatchesFunctionDefinitionStmt) {
1669  EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1670                         declStmt(isInTemplateInstantiation())));
1671}
1672
1673TEST(IsInTemplateInstantiation, Sharing) {
1674  auto Matcher = binaryOperator(unless(isInTemplateInstantiation()));
1675  // FIXME: Node sharing is an implementation detail, exposing it is ugly
1676  // and makes the matcher behave in non-obvious ways.
1677  EXPECT_TRUE(notMatches(
1678    "int j; template<typename T> void A(T t) { j += 42; } void x() { A(0); }",
1679    Matcher));
1680  EXPECT_TRUE(matches(
1681    "int j; template<typename T> void A(T t) { j += t; } void x() { A(0); }",
1682    Matcher));
1683}
1684
1685TEST(IsExplicitTemplateSpecialization,
1686     DoesNotMatchPrimaryTemplate) {
1687  EXPECT_TRUE(notMatches(
1688    "template <typename T> class X {};",
1689    cxxRecordDecl(isExplicitTemplateSpecialization())));
1690  EXPECT_TRUE(notMatches(
1691    "template <typename T> void f(T t);",
1692    functionDecl(isExplicitTemplateSpecialization())));
1693}
1694
1695TEST(IsExplicitTemplateSpecialization,
1696     DoesNotMatchExplicitTemplateInstantiations) {
1697  EXPECT_TRUE(notMatches(
1698    "template <typename T> class X {};"
1699      "template class X<int>; extern template class X<long>;",
1700    cxxRecordDecl(isExplicitTemplateSpecialization())));
1701  EXPECT_TRUE(notMatches(
1702    "template <typename T> void f(T t) {}"
1703      "template void f(int t); extern template void f(long t);",
1704    functionDecl(isExplicitTemplateSpecialization())));
1705}
1706
1707TEST(IsExplicitTemplateSpecialization,
1708     DoesNotMatchImplicitTemplateInstantiations) {
1709  EXPECT_TRUE(notMatches(
1710    "template <typename T> class X {}; X<int> x;",
1711    cxxRecordDecl(isExplicitTemplateSpecialization())));
1712  EXPECT_TRUE(notMatches(
1713    "template <typename T> void f(T t); void g() { f(10); }",
1714    functionDecl(isExplicitTemplateSpecialization())));
1715}
1716
1717TEST(IsExplicitTemplateSpecialization,
1718     MatchesExplicitTemplateSpecializations) {
1719  EXPECT_TRUE(matches(
1720    "template <typename T> class X {};"
1721      "template<> class X<int> {};",
1722    cxxRecordDecl(isExplicitTemplateSpecialization())));
1723  EXPECT_TRUE(matches(
1724    "template <typename T> void f(T t) {}"
1725      "template<> void f(int t) {}",
1726    functionDecl(isExplicitTemplateSpecialization())));
1727}
1728
1729TEST(TypeMatching, MatchesBool) {
1730  EXPECT_TRUE(matches("struct S { bool func(); };",
1731                      cxxMethodDecl(returns(booleanType()))));
1732  EXPECT_TRUE(notMatches("struct S { void func(); };",
1733                         cxxMethodDecl(returns(booleanType()))));
1734}
1735
1736TEST(TypeMatching, MatchesVoid) {
1737  EXPECT_TRUE(matches("struct S { void func(); };",
1738                      cxxMethodDecl(returns(voidType()))));
1739}
1740
1741TEST(TypeMatching, MatchesRealFloats) {
1742  EXPECT_TRUE(matches("struct S { float func(); };",
1743                      cxxMethodDecl(returns(realFloatingPointType()))));
1744  EXPECT_TRUE(notMatches("struct S { int func(); };",
1745                         cxxMethodDecl(returns(realFloatingPointType()))));
1746  EXPECT_TRUE(matches("struct S { long double func(); };",
1747                      cxxMethodDecl(returns(realFloatingPointType()))));
1748}
1749
1750TEST(TypeMatching, MatchesArrayTypes) {
1751  EXPECT_TRUE(matches("int a[] = {2,3};", arrayType()));
1752  EXPECT_TRUE(matches("int a[42];", arrayType()));
1753  EXPECT_TRUE(matches("void f(int b) { int a[b]; }", arrayType()));
1754
1755  EXPECT_TRUE(notMatches("struct A {}; A a[7];",
1756                         arrayType(hasElementType(builtinType()))));
1757
1758  EXPECT_TRUE(matches(
1759    "int const a[] = { 2, 3 };",
1760    qualType(arrayType(hasElementType(builtinType())))));
1761  EXPECT_TRUE(matches(
1762    "int const a[] = { 2, 3 };",
1763    qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
1764  EXPECT_TRUE(matches(
1765    "typedef const int T; T x[] = { 1, 2 };",
1766    qualType(isConstQualified(), arrayType())));
1767
1768  EXPECT_TRUE(notMatches(
1769    "int a[] = { 2, 3 };",
1770    qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
1771  EXPECT_TRUE(notMatches(
1772    "int a[] = { 2, 3 };",
1773    qualType(arrayType(hasElementType(isConstQualified(), builtinType())))));
1774  EXPECT_TRUE(notMatches(
1775    "int const a[] = { 2, 3 };",
1776    qualType(arrayType(hasElementType(builtinType())),
1777             unless(isConstQualified()))));
1778
1779  EXPECT_TRUE(matches("int a[2];",
1780                      constantArrayType(hasElementType(builtinType()))));
1781  EXPECT_TRUE(matches("const int a = 0;", qualType(isInteger())));
1782}
1783
1784TEST(TypeMatching, DecayedType) {
1785  EXPECT_TRUE(matches("void f(int i[]);", valueDecl(hasType(decayedType(hasDecayedType(pointerType()))))));
1786  EXPECT_TRUE(notMatches("int i[7];", decayedType()));
1787}
1788
1789TEST(TypeMatching, MatchesComplexTypes) {
1790  EXPECT_TRUE(matches("_Complex float f;", complexType()));
1791  EXPECT_TRUE(matches(
1792    "_Complex float f;",
1793    complexType(hasElementType(builtinType()))));
1794  EXPECT_TRUE(notMatches(
1795    "_Complex float f;",
1796    complexType(hasElementType(isInteger()))));
1797}
1798
1799TEST(NS, Anonymous) {
1800  EXPECT_TRUE(notMatches("namespace N {}", namespaceDecl(isAnonymous())));
1801  EXPECT_TRUE(matches("namespace {}", namespaceDecl(isAnonymous())));
1802}
1803
1804TEST(EqualsBoundNodeMatcher, QualType) {
1805  EXPECT_TRUE(matches(
1806    "int i = 1;", varDecl(hasType(qualType().bind("type")),
1807                          hasInitializer(ignoringParenImpCasts(
1808                            hasType(qualType(equalsBoundNode("type"))))))));
1809  EXPECT_TRUE(notMatches("int i = 1.f;",
1810                         varDecl(hasType(qualType().bind("type")),
1811                                 hasInitializer(ignoringParenImpCasts(hasType(
1812                                   qualType(equalsBoundNode("type"))))))));
1813}
1814
1815TEST(EqualsBoundNodeMatcher, NonMatchingTypes) {
1816  EXPECT_TRUE(notMatches(
1817    "int i = 1;", varDecl(namedDecl(hasName("i")).bind("name"),
1818                          hasInitializer(ignoringParenImpCasts(
1819                            hasType(qualType(equalsBoundNode("type"))))))));
1820}
1821
1822TEST(EqualsBoundNodeMatcher, Stmt) {
1823  EXPECT_TRUE(
1824    matches("void f() { if(true) {} }",
1825            stmt(allOf(ifStmt().bind("if"),
1826                       hasParent(stmt(has(stmt(equalsBoundNode("if")))))))));
1827
1828  EXPECT_TRUE(notMatches(
1829    "void f() { if(true) { if (true) {} } }",
1830    stmt(allOf(ifStmt().bind("if"), has(stmt(equalsBoundNode("if")))))));
1831}
1832
1833TEST(EqualsBoundNodeMatcher, Decl) {
1834  EXPECT_TRUE(matches(
1835    "class X { class Y {}; };",
1836    decl(allOf(recordDecl(hasName("::X::Y")).bind("record"),
1837               hasParent(decl(has(decl(equalsBoundNode("record")))))))));
1838
1839  EXPECT_TRUE(notMatches("class X { class Y {}; };",
1840                         decl(allOf(recordDecl(hasName("::X")).bind("record"),
1841                                    has(decl(equalsBoundNode("record")))))));
1842}
1843
1844TEST(EqualsBoundNodeMatcher, Type) {
1845  EXPECT_TRUE(matches(
1846    "class X { int a; int b; };",
1847    recordDecl(
1848      has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
1849      has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
1850
1851  EXPECT_TRUE(notMatches(
1852    "class X { int a; double b; };",
1853    recordDecl(
1854      has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
1855      has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
1856}
1857
1858TEST(EqualsBoundNodeMatcher, UsingForEachDescendant) {
1859  EXPECT_TRUE(matchAndVerifyResultTrue(
1860    "int f() {"
1861      "  if (1) {"
1862      "    int i = 9;"
1863      "  }"
1864      "  int j = 10;"
1865      "  {"
1866      "    float k = 9.0;"
1867      "  }"
1868      "  return 0;"
1869      "}",
1870    // Look for variable declarations within functions whose type is the same
1871    // as the function return type.
1872    functionDecl(returns(qualType().bind("type")),
1873                 forEachDescendant(varDecl(hasType(
1874                   qualType(equalsBoundNode("type")))).bind("decl"))),
1875    // Only i and j should match, not k.
1876    llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("decl", 2)));
1877}
1878
1879TEST(EqualsBoundNodeMatcher, FiltersMatchedCombinations) {
1880  EXPECT_TRUE(matchAndVerifyResultTrue(
1881    "void f() {"
1882      "  int x;"
1883      "  double d;"
1884      "  x = d + x - d + x;"
1885      "}",
1886    functionDecl(
1887      hasName("f"), forEachDescendant(varDecl().bind("d")),
1888      forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d")))))),
1889    llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("d", 5)));
1890}
1891
1892TEST(EqualsBoundNodeMatcher, UnlessDescendantsOfAncestorsMatch) {
1893  EXPECT_TRUE(matchAndVerifyResultTrue(
1894    "struct StringRef { int size() const; const char* data() const; };"
1895      "void f(StringRef v) {"
1896      "  v.data();"
1897      "}",
1898    cxxMemberCallExpr(
1899      callee(cxxMethodDecl(hasName("data"))),
1900      on(declRefExpr(to(
1901        varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
1902      unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
1903        callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
1904        on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
1905      .bind("data"),
1906    llvm::make_unique<VerifyIdIsBoundTo<Expr>>("data", 1)));
1907
1908  EXPECT_FALSE(matches(
1909    "struct StringRef { int size() const; const char* data() const; };"
1910      "void f(StringRef v) {"
1911      "  v.data();"
1912      "  v.size();"
1913      "}",
1914    cxxMemberCallExpr(
1915      callee(cxxMethodDecl(hasName("data"))),
1916      on(declRefExpr(to(
1917        varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
1918      unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
1919        callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
1920        on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
1921      .bind("data")));
1922}
1923
1924TEST(NullPointerConstants, Basic) {
1925  EXPECT_TRUE(matches("#define NULL ((void *)0)\n"
1926                        "void *v1 = NULL;", expr(nullPointerConstant())));
1927  EXPECT_TRUE(matches("void *v2 = nullptr;", expr(nullPointerConstant())));
1928  EXPECT_TRUE(matches("void *v3 = __null;", expr(nullPointerConstant())));
1929  EXPECT_TRUE(matches("char *cp = (char *)0;", expr(nullPointerConstant())));
1930  EXPECT_TRUE(matches("int *ip = 0;", expr(nullPointerConstant())));
1931  EXPECT_TRUE(notMatches("int i = 0;", expr(nullPointerConstant())));
1932}
1933
1934} // namespace ast_matchers
1935} // namespace clang
1936