blob: 6eb552aa564916bbf8f4779e69e93aec40d6777b [file] [log] [blame]
Manuel Klimek4da21662012-07-06 05:48:52 +00001//===- 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"
Benjamin Kramer8b9ed712012-12-01 17:22:05 +000011#include "clang/AST/PrettyPrinter.h"
Manuel Klimek4da21662012-07-06 05:48:52 +000012#include "clang/ASTMatchers/ASTMatchFinder.h"
Chandler Carruth1050e8b2012-12-04 09:45:34 +000013#include "clang/ASTMatchers/ASTMatchers.h"
Manuel Klimek4da21662012-07-06 05:48:52 +000014#include "clang/Tooling/Tooling.h"
15#include "gtest/gtest.h"
16
17namespace clang {
18namespace ast_matchers {
19
Benjamin Kramer78a0ce42012-07-10 17:30:44 +000020#if GTEST_HAS_DEATH_TEST
Manuel Klimek4da21662012-07-06 05:48:52 +000021TEST(HasNameDeathTest, DiesOnEmptyName) {
22 ASSERT_DEBUG_DEATH({
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000023 DeclarationMatcher HasEmptyName = recordDecl(hasName(""));
Manuel Klimek4da21662012-07-06 05:48:52 +000024 EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
25 }, "");
26}
27
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000028TEST(HasNameDeathTest, DiesOnEmptyPattern) {
29 ASSERT_DEBUG_DEATH({
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000030 DeclarationMatcher HasEmptyName = recordDecl(matchesName(""));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000031 EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
32 }, "");
33}
34
Manuel Klimek4da21662012-07-06 05:48:52 +000035TEST(IsDerivedFromDeathTest, DiesOnEmptyBaseName) {
36 ASSERT_DEBUG_DEATH({
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000037 DeclarationMatcher IsDerivedFromEmpty = recordDecl(isDerivedFrom(""));
Manuel Klimek4da21662012-07-06 05:48:52 +000038 EXPECT_TRUE(notMatches("class X {};", IsDerivedFromEmpty));
39 }, "");
40}
Benjamin Kramer78a0ce42012-07-10 17:30:44 +000041#endif
Manuel Klimek4da21662012-07-06 05:48:52 +000042
Manuel Klimek715c9562012-07-25 10:02:02 +000043TEST(Decl, MatchesDeclarations) {
44 EXPECT_TRUE(notMatches("", decl(usingDecl())));
45 EXPECT_TRUE(matches("namespace x { class X {}; } using x::X;",
46 decl(usingDecl())));
47}
48
Manuel Klimek4da21662012-07-06 05:48:52 +000049TEST(NameableDeclaration, MatchesVariousDecls) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000050 DeclarationMatcher NamedX = namedDecl(hasName("X"));
Manuel Klimek4da21662012-07-06 05:48:52 +000051 EXPECT_TRUE(matches("typedef int X;", NamedX));
52 EXPECT_TRUE(matches("int X;", NamedX));
53 EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
54 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
55 EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
56 EXPECT_TRUE(matches("namespace X { }", NamedX));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000057 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
Manuel Klimek4da21662012-07-06 05:48:52 +000058
59 EXPECT_TRUE(notMatches("#define X 1", NamedX));
60}
61
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000062TEST(NameableDeclaration, REMatchesVariousDecls) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000063 DeclarationMatcher NamedX = namedDecl(matchesName("::X"));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000064 EXPECT_TRUE(matches("typedef int Xa;", NamedX));
65 EXPECT_TRUE(matches("int Xb;", NamedX));
66 EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
67 EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
68 EXPECT_TRUE(matches("void foo() { int Xgh; }", NamedX));
69 EXPECT_TRUE(matches("namespace Xij { }", NamedX));
70 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
71
72 EXPECT_TRUE(notMatches("#define Xkl 1", NamedX));
73
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000074 DeclarationMatcher StartsWithNo = namedDecl(matchesName("::no"));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000075 EXPECT_TRUE(matches("int no_foo;", StartsWithNo));
76 EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
77
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000078 DeclarationMatcher Abc = namedDecl(matchesName("a.*b.*c"));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000079 EXPECT_TRUE(matches("int abc;", Abc));
80 EXPECT_TRUE(matches("int aFOObBARc;", Abc));
81 EXPECT_TRUE(notMatches("int cab;", Abc));
82 EXPECT_TRUE(matches("int cabc;", Abc));
Manuel Klimekec33b6f2012-12-10 07:08:53 +000083
84 DeclarationMatcher StartsWithK = namedDecl(matchesName(":k[^:]*$"));
85 EXPECT_TRUE(matches("int k;", StartsWithK));
86 EXPECT_TRUE(matches("int kAbc;", StartsWithK));
87 EXPECT_TRUE(matches("namespace x { int kTest; }", StartsWithK));
88 EXPECT_TRUE(matches("class C { int k; };", StartsWithK));
89 EXPECT_TRUE(notMatches("class C { int ckc; };", StartsWithK));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +000090}
91
Manuel Klimek4da21662012-07-06 05:48:52 +000092TEST(DeclarationMatcher, MatchClass) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +000093 DeclarationMatcher ClassMatcher(recordDecl());
Manuel Klimeke265c872012-07-10 14:21:30 +000094#if !defined(_MSC_VER)
Manuel Klimek4da21662012-07-06 05:48:52 +000095 EXPECT_FALSE(matches("", ClassMatcher));
Manuel Klimeke265c872012-07-10 14:21:30 +000096#else
97 // Matches class type_info.
98 EXPECT_TRUE(matches("", ClassMatcher));
99#endif
Manuel Klimek4da21662012-07-06 05:48:52 +0000100
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000101 DeclarationMatcher ClassX = recordDecl(recordDecl(hasName("X")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000102 EXPECT_TRUE(matches("class X;", ClassX));
103 EXPECT_TRUE(matches("class X {};", ClassX));
104 EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
105 EXPECT_TRUE(notMatches("", ClassX));
106}
107
108TEST(DeclarationMatcher, ClassIsDerived) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000109 DeclarationMatcher IsDerivedFromX = recordDecl(isDerivedFrom("X"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000110
111 EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
Daniel Jasper76dafa72012-09-07 12:48:17 +0000112 EXPECT_TRUE(notMatches("class X {};", IsDerivedFromX));
113 EXPECT_TRUE(notMatches("class X;", IsDerivedFromX));
Manuel Klimek4da21662012-07-06 05:48:52 +0000114 EXPECT_TRUE(notMatches("class Y;", IsDerivedFromX));
115 EXPECT_TRUE(notMatches("", IsDerivedFromX));
116
Daniel Jasper63d88722012-09-12 21:14:15 +0000117 DeclarationMatcher IsAX = recordDecl(isSameOrDerivedFrom("X"));
Daniel Jasper76dafa72012-09-07 12:48:17 +0000118
119 EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsAX));
120 EXPECT_TRUE(matches("class X {};", IsAX));
121 EXPECT_TRUE(matches("class X;", IsAX));
122 EXPECT_TRUE(notMatches("class Y;", IsAX));
123 EXPECT_TRUE(notMatches("", IsAX));
124
Manuel Klimek4da21662012-07-06 05:48:52 +0000125 DeclarationMatcher ZIsDerivedFromX =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000126 recordDecl(hasName("Z"), isDerivedFrom("X"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000127 EXPECT_TRUE(
128 matches("class X {}; class Y : public X {}; class Z : public Y {};",
129 ZIsDerivedFromX));
130 EXPECT_TRUE(
131 matches("class X {};"
132 "template<class T> class Y : public X {};"
133 "class Z : public Y<int> {};", ZIsDerivedFromX));
134 EXPECT_TRUE(matches("class X {}; template<class T> class Z : public X {};",
135 ZIsDerivedFromX));
136 EXPECT_TRUE(
137 matches("template<class T> class X {}; "
138 "template<class T> class Z : public X<T> {};",
139 ZIsDerivedFromX));
140 EXPECT_TRUE(
141 matches("template<class T, class U=T> class X {}; "
142 "template<class T> class Z : public X<T> {};",
143 ZIsDerivedFromX));
144 EXPECT_TRUE(
145 notMatches("template<class X> class A { class Z : public X {}; };",
146 ZIsDerivedFromX));
147 EXPECT_TRUE(
148 matches("template<class X> class A { public: class Z : public X {}; }; "
149 "class X{}; void y() { A<X>::Z z; }", ZIsDerivedFromX));
150 EXPECT_TRUE(
151 matches("template <class T> class X {}; "
152 "template<class Y> class A { class Z : public X<Y> {}; };",
153 ZIsDerivedFromX));
154 EXPECT_TRUE(
155 notMatches("template<template<class T> class X> class A { "
156 " class Z : public X<int> {}; };", ZIsDerivedFromX));
157 EXPECT_TRUE(
158 matches("template<template<class T> class X> class A { "
159 " public: class Z : public X<int> {}; }; "
160 "template<class T> class X {}; void y() { A<X>::Z z; }",
161 ZIsDerivedFromX));
162 EXPECT_TRUE(
163 notMatches("template<class X> class A { class Z : public X::D {}; };",
164 ZIsDerivedFromX));
165 EXPECT_TRUE(
166 matches("template<class X> class A { public: "
167 " class Z : public X::D {}; }; "
168 "class Y { public: class X {}; typedef X D; }; "
169 "void y() { A<Y>::Z z; }", ZIsDerivedFromX));
170 EXPECT_TRUE(
171 matches("class X {}; typedef X Y; class Z : public Y {};",
172 ZIsDerivedFromX));
173 EXPECT_TRUE(
174 matches("template<class T> class Y { typedef typename T::U X; "
175 " class Z : public X {}; };", ZIsDerivedFromX));
176 EXPECT_TRUE(matches("class X {}; class Z : public ::X {};",
177 ZIsDerivedFromX));
178 EXPECT_TRUE(
179 notMatches("template<class T> class X {}; "
180 "template<class T> class A { class Z : public X<T>::D {}; };",
181 ZIsDerivedFromX));
182 EXPECT_TRUE(
183 matches("template<class T> class X { public: typedef X<T> D; }; "
184 "template<class T> class A { public: "
185 " class Z : public X<T>::D {}; }; void y() { A<int>::Z z; }",
186 ZIsDerivedFromX));
187 EXPECT_TRUE(
188 notMatches("template<class X> class A { class Z : public X::D::E {}; };",
189 ZIsDerivedFromX));
190 EXPECT_TRUE(
191 matches("class X {}; typedef X V; typedef V W; class Z : public W {};",
192 ZIsDerivedFromX));
193 EXPECT_TRUE(
194 matches("class X {}; class Y : public X {}; "
195 "typedef Y V; typedef V W; class Z : public W {};",
196 ZIsDerivedFromX));
197 EXPECT_TRUE(
198 matches("template<class T, class U> class X {}; "
199 "template<class T> class A { class Z : public X<T, int> {}; };",
200 ZIsDerivedFromX));
201 EXPECT_TRUE(
202 notMatches("template<class X> class D { typedef X A; typedef A B; "
203 " typedef B C; class Z : public C {}; };",
204 ZIsDerivedFromX));
205 EXPECT_TRUE(
206 matches("class X {}; typedef X A; typedef A B; "
207 "class Z : public B {};", ZIsDerivedFromX));
208 EXPECT_TRUE(
209 matches("class X {}; typedef X A; typedef A B; typedef B C; "
210 "class Z : public C {};", ZIsDerivedFromX));
211 EXPECT_TRUE(
212 matches("class U {}; typedef U X; typedef X V; "
213 "class Z : public V {};", ZIsDerivedFromX));
214 EXPECT_TRUE(
215 matches("class Base {}; typedef Base X; "
216 "class Z : public Base {};", ZIsDerivedFromX));
217 EXPECT_TRUE(
218 matches("class Base {}; typedef Base Base2; typedef Base2 X; "
219 "class Z : public Base {};", ZIsDerivedFromX));
220 EXPECT_TRUE(
221 notMatches("class Base {}; class Base2 {}; typedef Base2 X; "
222 "class Z : public Base {};", ZIsDerivedFromX));
223 EXPECT_TRUE(
224 matches("class A {}; typedef A X; typedef A Y; "
225 "class Z : public Y {};", ZIsDerivedFromX));
226 EXPECT_TRUE(
227 notMatches("template <typename T> class Z;"
228 "template <> class Z<void> {};"
229 "template <typename T> class Z : public Z<void> {};",
230 IsDerivedFromX));
231 EXPECT_TRUE(
232 matches("template <typename T> class X;"
233 "template <> class X<void> {};"
234 "template <typename T> class X : public X<void> {};",
235 IsDerivedFromX));
236 EXPECT_TRUE(matches(
237 "class X {};"
238 "template <typename T> class Z;"
239 "template <> class Z<void> {};"
240 "template <typename T> class Z : public Z<void>, public X {};",
241 ZIsDerivedFromX));
Manuel Klimek987c2f52012-12-04 13:40:29 +0000242 EXPECT_TRUE(
243 notMatches("template<int> struct X;"
244 "template<int i> struct X : public X<i-1> {};",
245 recordDecl(isDerivedFrom(recordDecl(hasName("Some"))))));
246 EXPECT_TRUE(matches(
247 "struct A {};"
248 "template<int> struct X;"
249 "template<int i> struct X : public X<i-1> {};"
250 "template<> struct X<0> : public A {};"
251 "struct B : public X<42> {};",
252 recordDecl(hasName("B"), isDerivedFrom(recordDecl(hasName("A"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000253
254 // FIXME: Once we have better matchers for template type matching,
255 // get rid of the Variable(...) matching and match the right template
256 // declarations directly.
257 const char *RecursiveTemplateOneParameter =
258 "class Base1 {}; class Base2 {};"
259 "template <typename T> class Z;"
260 "template <> class Z<void> : public Base1 {};"
261 "template <> class Z<int> : public Base2 {};"
262 "template <> class Z<float> : public Z<void> {};"
263 "template <> class Z<double> : public Z<int> {};"
264 "template <typename T> class Z : public Z<float>, public Z<double> {};"
265 "void f() { Z<float> z_float; Z<double> z_double; Z<char> z_char; }";
266 EXPECT_TRUE(matches(
267 RecursiveTemplateOneParameter,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000268 varDecl(hasName("z_float"),
269 hasInitializer(hasType(recordDecl(isDerivedFrom("Base1")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000270 EXPECT_TRUE(notMatches(
271 RecursiveTemplateOneParameter,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000272 varDecl(hasName("z_float"),
273 hasInitializer(hasType(recordDecl(isDerivedFrom("Base2")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000274 EXPECT_TRUE(matches(
275 RecursiveTemplateOneParameter,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000276 varDecl(hasName("z_char"),
277 hasInitializer(hasType(recordDecl(isDerivedFrom("Base1"),
278 isDerivedFrom("Base2")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000279
280 const char *RecursiveTemplateTwoParameters =
281 "class Base1 {}; class Base2 {};"
282 "template <typename T1, typename T2> class Z;"
283 "template <typename T> class Z<void, T> : public Base1 {};"
284 "template <typename T> class Z<int, T> : public Base2 {};"
285 "template <typename T> class Z<float, T> : public Z<void, T> {};"
286 "template <typename T> class Z<double, T> : public Z<int, T> {};"
287 "template <typename T1, typename T2> class Z : "
288 " public Z<float, T2>, public Z<double, T2> {};"
289 "void f() { Z<float, void> z_float; Z<double, void> z_double; "
290 " Z<char, void> z_char; }";
291 EXPECT_TRUE(matches(
292 RecursiveTemplateTwoParameters,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000293 varDecl(hasName("z_float"),
294 hasInitializer(hasType(recordDecl(isDerivedFrom("Base1")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000295 EXPECT_TRUE(notMatches(
296 RecursiveTemplateTwoParameters,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000297 varDecl(hasName("z_float"),
298 hasInitializer(hasType(recordDecl(isDerivedFrom("Base2")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000299 EXPECT_TRUE(matches(
300 RecursiveTemplateTwoParameters,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000301 varDecl(hasName("z_char"),
302 hasInitializer(hasType(recordDecl(isDerivedFrom("Base1"),
303 isDerivedFrom("Base2")))))));
Daniel Jasper20b802d2012-07-17 07:39:27 +0000304 EXPECT_TRUE(matches(
305 "namespace ns { class X {}; class Y : public X {}; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000306 recordDecl(isDerivedFrom("::ns::X"))));
Daniel Jasper20b802d2012-07-17 07:39:27 +0000307 EXPECT_TRUE(notMatches(
308 "class X {}; class Y : public X {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000309 recordDecl(isDerivedFrom("::ns::X"))));
Daniel Jasper20b802d2012-07-17 07:39:27 +0000310
311 EXPECT_TRUE(matches(
312 "class X {}; class Y : public X {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000313 recordDecl(isDerivedFrom(recordDecl(hasName("X")).bind("test")))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000314}
315
Daniel Jasper08f0c532012-09-18 14:17:42 +0000316TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
317 EXPECT_TRUE(matches(
318 "template <typename T> struct A {"
319 " template <typename T2> struct F {};"
320 "};"
321 "template <typename T> struct B : A<T>::template F<T> {};"
322 "B<int> b;",
323 recordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
324}
325
Dmitri Gribenko8456ae62012-08-17 18:42:47 +0000326TEST(ClassTemplate, DoesNotMatchClass) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000327 DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +0000328 EXPECT_TRUE(notMatches("class X;", ClassX));
329 EXPECT_TRUE(notMatches("class X {};", ClassX));
330}
331
332TEST(ClassTemplate, MatchesClassTemplate) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000333 DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +0000334 EXPECT_TRUE(matches("template<typename T> class X {};", ClassX));
335 EXPECT_TRUE(matches("class Z { template<class T> class X {}; };", ClassX));
336}
337
338TEST(ClassTemplate, DoesNotMatchClassTemplateExplicitSpecialization) {
339 EXPECT_TRUE(notMatches("template<typename T> class X { };"
340 "template<> class X<int> { int a; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000341 classTemplateDecl(hasName("X"),
342 hasDescendant(fieldDecl(hasName("a"))))));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +0000343}
344
345TEST(ClassTemplate, DoesNotMatchClassTemplatePartialSpecialization) {
346 EXPECT_TRUE(notMatches("template<typename T, typename U> class X { };"
347 "template<typename T> class X<T, int> { int a; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000348 classTemplateDecl(hasName("X"),
349 hasDescendant(fieldDecl(hasName("a"))))));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +0000350}
351
Daniel Jasper6a124492012-07-12 08:50:38 +0000352TEST(AllOf, AllOverloadsWork) {
353 const char Program[] =
Edwin Vane7f43fcf2013-02-12 13:55:40 +0000354 "struct T { };"
355 "int f(int, T*, int, int);"
356 "void g(int x) { T t; f(x, &t, 3, 4); }";
Daniel Jasper6a124492012-07-12 08:50:38 +0000357 EXPECT_TRUE(matches(Program,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000358 callExpr(allOf(callee(functionDecl(hasName("f"))),
359 hasArgument(0, declRefExpr(to(varDecl())))))));
Daniel Jasper6a124492012-07-12 08:50:38 +0000360 EXPECT_TRUE(matches(Program,
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000361 callExpr(allOf(callee(functionDecl(hasName("f"))),
362 hasArgument(0, declRefExpr(to(varDecl()))),
363 hasArgument(1, hasType(pointsTo(
364 recordDecl(hasName("T")))))))));
Edwin Vane7f43fcf2013-02-12 13:55:40 +0000365 EXPECT_TRUE(matches(Program,
366 callExpr(allOf(callee(functionDecl(hasName("f"))),
367 hasArgument(0, declRefExpr(to(varDecl()))),
368 hasArgument(1, hasType(pointsTo(
369 recordDecl(hasName("T"))))),
370 hasArgument(2, integerLiteral(equals(3)))))));
371 EXPECT_TRUE(matches(Program,
372 callExpr(allOf(callee(functionDecl(hasName("f"))),
373 hasArgument(0, declRefExpr(to(varDecl()))),
374 hasArgument(1, hasType(pointsTo(
375 recordDecl(hasName("T"))))),
376 hasArgument(2, integerLiteral(equals(3))),
377 hasArgument(3, integerLiteral(equals(4)))))));
Daniel Jasper6a124492012-07-12 08:50:38 +0000378}
379
Manuel Klimek4da21662012-07-06 05:48:52 +0000380TEST(DeclarationMatcher, MatchAnyOf) {
381 DeclarationMatcher YOrZDerivedFromX =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000382 recordDecl(anyOf(hasName("Y"), allOf(isDerivedFrom("X"), hasName("Z"))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000383 EXPECT_TRUE(
384 matches("class X {}; class Z : public X {};", YOrZDerivedFromX));
385 EXPECT_TRUE(matches("class Y {};", YOrZDerivedFromX));
386 EXPECT_TRUE(
387 notMatches("class X {}; class W : public X {};", YOrZDerivedFromX));
388 EXPECT_TRUE(notMatches("class Z {};", YOrZDerivedFromX));
389
Daniel Jasperff2fcb82012-07-15 19:57:12 +0000390 DeclarationMatcher XOrYOrZOrU =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000391 recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U")));
Daniel Jasperff2fcb82012-07-15 19:57:12 +0000392 EXPECT_TRUE(matches("class X {};", XOrYOrZOrU));
393 EXPECT_TRUE(notMatches("class V {};", XOrYOrZOrU));
394
Manuel Klimek4da21662012-07-06 05:48:52 +0000395 DeclarationMatcher XOrYOrZOrUOrV =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000396 recordDecl(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U"),
397 hasName("V")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000398 EXPECT_TRUE(matches("class X {};", XOrYOrZOrUOrV));
399 EXPECT_TRUE(matches("class Y {};", XOrYOrZOrUOrV));
400 EXPECT_TRUE(matches("class Z {};", XOrYOrZOrUOrV));
401 EXPECT_TRUE(matches("class U {};", XOrYOrZOrUOrV));
402 EXPECT_TRUE(matches("class V {};", XOrYOrZOrUOrV));
403 EXPECT_TRUE(notMatches("class A {};", XOrYOrZOrUOrV));
404}
405
406TEST(DeclarationMatcher, MatchHas) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000407 DeclarationMatcher HasClassX = recordDecl(has(recordDecl(hasName("X"))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000408 EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
409 EXPECT_TRUE(matches("class X {};", HasClassX));
410
411 DeclarationMatcher YHasClassX =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000412 recordDecl(hasName("Y"), has(recordDecl(hasName("X"))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000413 EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
414 EXPECT_TRUE(notMatches("class X {};", YHasClassX));
415 EXPECT_TRUE(
416 notMatches("class Y { class Z { class X {}; }; };", YHasClassX));
417}
418
419TEST(DeclarationMatcher, MatchHasRecursiveAllOf) {
420 DeclarationMatcher Recursive =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000421 recordDecl(
422 has(recordDecl(
423 has(recordDecl(hasName("X"))),
424 has(recordDecl(hasName("Y"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000425 hasName("Z"))),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000426 has(recordDecl(
427 has(recordDecl(hasName("A"))),
428 has(recordDecl(hasName("B"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000429 hasName("C"))),
430 hasName("F"));
431
432 EXPECT_TRUE(matches(
433 "class F {"
434 " class Z {"
435 " class X {};"
436 " class Y {};"
437 " };"
438 " class C {"
439 " class A {};"
440 " class B {};"
441 " };"
442 "};", Recursive));
443
444 EXPECT_TRUE(matches(
445 "class F {"
446 " class Z {"
447 " class A {};"
448 " class X {};"
449 " class Y {};"
450 " };"
451 " class C {"
452 " class X {};"
453 " class A {};"
454 " class B {};"
455 " };"
456 "};", Recursive));
457
458 EXPECT_TRUE(matches(
459 "class O1 {"
460 " class O2 {"
461 " class F {"
462 " class Z {"
463 " class A {};"
464 " class X {};"
465 " class Y {};"
466 " };"
467 " class C {"
468 " class X {};"
469 " class A {};"
470 " class B {};"
471 " };"
472 " };"
473 " };"
474 "};", Recursive));
475}
476
477TEST(DeclarationMatcher, MatchHasRecursiveAnyOf) {
478 DeclarationMatcher Recursive =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000479 recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000480 anyOf(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000481 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000482 anyOf(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000483 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000484 hasName("X"))),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000485 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000486 hasName("Y"))),
487 hasName("Z")))),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000488 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000489 anyOf(
490 hasName("C"),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000491 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000492 hasName("A"))),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000493 has(recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000494 hasName("B")))))),
495 hasName("F")));
496
497 EXPECT_TRUE(matches("class F {};", Recursive));
498 EXPECT_TRUE(matches("class Z {};", Recursive));
499 EXPECT_TRUE(matches("class C {};", Recursive));
500 EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
501 EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
502 EXPECT_TRUE(
503 matches("class O1 { class O2 {"
504 " class M { class N { class B {}; }; }; "
505 "}; };", Recursive));
506}
507
508TEST(DeclarationMatcher, MatchNot) {
509 DeclarationMatcher NotClassX =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000510 recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000511 isDerivedFrom("Y"),
Manuel Klimek4da21662012-07-06 05:48:52 +0000512 unless(hasName("X")));
513 EXPECT_TRUE(notMatches("", NotClassX));
514 EXPECT_TRUE(notMatches("class Y {};", NotClassX));
515 EXPECT_TRUE(matches("class Y {}; class Z : public Y {};", NotClassX));
516 EXPECT_TRUE(notMatches("class Y {}; class X : public Y {};", NotClassX));
517 EXPECT_TRUE(
518 notMatches("class Y {}; class Z {}; class X : public Y {};",
519 NotClassX));
520
521 DeclarationMatcher ClassXHasNotClassY =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000522 recordDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +0000523 hasName("X"),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000524 has(recordDecl(hasName("Z"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000525 unless(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000526 has(recordDecl(hasName("Y")))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000527 EXPECT_TRUE(matches("class X { class Z {}; };", ClassXHasNotClassY));
528 EXPECT_TRUE(notMatches("class X { class Y {}; class Z {}; };",
529 ClassXHasNotClassY));
530}
531
532TEST(DeclarationMatcher, HasDescendant) {
533 DeclarationMatcher ZDescendantClassX =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000534 recordDecl(
535 hasDescendant(recordDecl(hasName("X"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000536 hasName("Z"));
537 EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
538 EXPECT_TRUE(
539 matches("class Z { class Y { class X {}; }; };", ZDescendantClassX));
540 EXPECT_TRUE(
541 matches("class Z { class A { class Y { class X {}; }; }; };",
542 ZDescendantClassX));
543 EXPECT_TRUE(
544 matches("class Z { class A { class B { class Y { class X {}; }; }; }; };",
545 ZDescendantClassX));
546 EXPECT_TRUE(notMatches("class Z {};", ZDescendantClassX));
547
548 DeclarationMatcher ZDescendantClassXHasClassY =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000549 recordDecl(
550 hasDescendant(recordDecl(has(recordDecl(hasName("Y"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000551 hasName("X"))),
552 hasName("Z"));
553 EXPECT_TRUE(matches("class Z { class X { class Y {}; }; };",
554 ZDescendantClassXHasClassY));
555 EXPECT_TRUE(
556 matches("class Z { class A { class B { class X { class Y {}; }; }; }; };",
557 ZDescendantClassXHasClassY));
558 EXPECT_TRUE(notMatches(
559 "class Z {"
560 " class A {"
561 " class B {"
562 " class X {"
563 " class C {"
564 " class Y {};"
565 " };"
566 " };"
567 " }; "
568 " };"
569 "};", ZDescendantClassXHasClassY));
570
571 DeclarationMatcher ZDescendantClassXDescendantClassY =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000572 recordDecl(
573 hasDescendant(recordDecl(hasDescendant(recordDecl(hasName("Y"))),
574 hasName("X"))),
Manuel Klimek4da21662012-07-06 05:48:52 +0000575 hasName("Z"));
576 EXPECT_TRUE(
577 matches("class Z { class A { class X { class B { class Y {}; }; }; }; };",
578 ZDescendantClassXDescendantClassY));
579 EXPECT_TRUE(matches(
580 "class Z {"
581 " class A {"
582 " class X {"
583 " class B {"
584 " class Y {};"
585 " };"
586 " class Y {};"
587 " };"
588 " };"
589 "};", ZDescendantClassXDescendantClassY));
590}
591
Daniel Jaspera267cf62012-10-29 10:14:44 +0000592// Implements a run method that returns whether BoundNodes contains a
593// Decl bound to Id that can be dynamically cast to T.
594// Optionally checks that the check succeeded a specific number of times.
595template <typename T>
596class VerifyIdIsBoundTo : public BoundNodesCallback {
597public:
598 // Create an object that checks that a node of type \c T was bound to \c Id.
599 // Does not check for a certain number of matches.
600 explicit VerifyIdIsBoundTo(llvm::StringRef Id)
601 : Id(Id), ExpectedCount(-1), Count(0) {}
602
603 // Create an object that checks that a node of type \c T was bound to \c Id.
604 // Checks that there were exactly \c ExpectedCount matches.
605 VerifyIdIsBoundTo(llvm::StringRef Id, int ExpectedCount)
606 : Id(Id), ExpectedCount(ExpectedCount), Count(0) {}
607
608 // Create an object that checks that a node of type \c T was bound to \c Id.
609 // Checks that there was exactly one match with the name \c ExpectedName.
610 // Note that \c T must be a NamedDecl for this to work.
611 VerifyIdIsBoundTo(llvm::StringRef Id, llvm::StringRef ExpectedName)
612 : Id(Id), ExpectedCount(1), Count(0), ExpectedName(ExpectedName) {}
613
614 ~VerifyIdIsBoundTo() {
615 if (ExpectedCount != -1)
616 EXPECT_EQ(ExpectedCount, Count);
617 if (!ExpectedName.empty())
618 EXPECT_EQ(ExpectedName, Name);
619 }
620
621 virtual bool run(const BoundNodes *Nodes) {
622 if (Nodes->getNodeAs<T>(Id)) {
623 ++Count;
624 if (const NamedDecl *Named = Nodes->getNodeAs<NamedDecl>(Id)) {
625 Name = Named->getNameAsString();
626 } else if (const NestedNameSpecifier *NNS =
627 Nodes->getNodeAs<NestedNameSpecifier>(Id)) {
628 llvm::raw_string_ostream OS(Name);
629 NNS->print(OS, PrintingPolicy(LangOptions()));
630 }
631 return true;
632 }
633 return false;
634 }
635
Daniel Jasper452abbc2012-10-29 10:48:25 +0000636 virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
637 return run(Nodes);
638 }
639
Daniel Jaspera267cf62012-10-29 10:14:44 +0000640private:
641 const std::string Id;
642 const int ExpectedCount;
643 int Count;
644 const std::string ExpectedName;
645 std::string Name;
646};
647
648TEST(HasDescendant, MatchesDescendantTypes) {
649 EXPECT_TRUE(matches("void f() { int i = 3; }",
650 decl(hasDescendant(loc(builtinType())))));
651 EXPECT_TRUE(matches("void f() { int i = 3; }",
652 stmt(hasDescendant(builtinType()))));
653
654 EXPECT_TRUE(matches("void f() { int i = 3; }",
655 stmt(hasDescendant(loc(builtinType())))));
656 EXPECT_TRUE(matches("void f() { int i = 3; }",
657 stmt(hasDescendant(qualType(builtinType())))));
658
659 EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
660 stmt(hasDescendant(isInteger()))));
661
662 EXPECT_TRUE(matchAndVerifyResultTrue(
663 "void f() { int a; float c; int d; int e; }",
664 functionDecl(forEachDescendant(
665 varDecl(hasDescendant(isInteger())).bind("x"))),
666 new VerifyIdIsBoundTo<Decl>("x", 3)));
667}
668
669TEST(HasDescendant, MatchesDescendantsOfTypes) {
670 EXPECT_TRUE(matches("void f() { int*** i; }",
671 qualType(hasDescendant(builtinType()))));
672 EXPECT_TRUE(matches("void f() { int*** i; }",
673 qualType(hasDescendant(
674 pointerType(pointee(builtinType()))))));
675 EXPECT_TRUE(matches("void f() { int*** i; }",
David Blaikie5be093c2013-02-18 19:04:16 +0000676 typeLoc(hasDescendant(loc(builtinType())))));
Daniel Jaspera267cf62012-10-29 10:14:44 +0000677
678 EXPECT_TRUE(matchAndVerifyResultTrue(
679 "void f() { int*** i; }",
680 qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
681 new VerifyIdIsBoundTo<Type>("x", 2)));
682}
683
684TEST(Has, MatchesChildrenOfTypes) {
685 EXPECT_TRUE(matches("int i;",
686 varDecl(hasName("i"), has(isInteger()))));
687 EXPECT_TRUE(notMatches("int** i;",
688 varDecl(hasName("i"), has(isInteger()))));
689 EXPECT_TRUE(matchAndVerifyResultTrue(
690 "int (*f)(float, int);",
691 qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
692 new VerifyIdIsBoundTo<QualType>("x", 2)));
693}
694
695TEST(Has, MatchesChildTypes) {
696 EXPECT_TRUE(matches(
697 "int* i;",
698 varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
699 EXPECT_TRUE(notMatches(
700 "int* i;",
701 varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
702}
703
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000704TEST(Enum, DoesNotMatchClasses) {
705 EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
706}
707
708TEST(Enum, MatchesEnums) {
709 EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
710}
711
712TEST(EnumConstant, Matches) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000713 DeclarationMatcher Matcher = enumConstantDecl(hasName("A"));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000714 EXPECT_TRUE(matches("enum X{ A };", Matcher));
715 EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
716 EXPECT_TRUE(notMatches("enum X {};", Matcher));
717}
718
Manuel Klimek4da21662012-07-06 05:48:52 +0000719TEST(StatementMatcher, Has) {
720 StatementMatcher HasVariableI =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000721 expr(hasType(pointsTo(recordDecl(hasName("X")))),
722 has(declRefExpr(to(varDecl(hasName("i"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000723
724 EXPECT_TRUE(matches(
725 "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
726 EXPECT_TRUE(notMatches(
727 "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
728}
729
730TEST(StatementMatcher, HasDescendant) {
731 StatementMatcher HasDescendantVariableI =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000732 expr(hasType(pointsTo(recordDecl(hasName("X")))),
733 hasDescendant(declRefExpr(to(varDecl(hasName("i"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000734
735 EXPECT_TRUE(matches(
736 "class X; X *x(bool); bool b(int); void c() { int i; x(b(i)); }",
737 HasDescendantVariableI));
738 EXPECT_TRUE(notMatches(
739 "class X; X *x(bool); bool b(int); void c() { int i; x(b(42)); }",
740 HasDescendantVariableI));
741}
742
743TEST(TypeMatcher, MatchesClassType) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000744 TypeMatcher TypeA = hasDeclaration(recordDecl(hasName("A")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000745
746 EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
747 EXPECT_TRUE(notMatches("class A {};", TypeA));
748
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000749 TypeMatcher TypeDerivedFromA = hasDeclaration(recordDecl(isDerivedFrom("A")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000750
751 EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
752 TypeDerivedFromA));
753 EXPECT_TRUE(notMatches("class A {};", TypeA));
754
755 TypeMatcher TypeAHasClassB = hasDeclaration(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000756 recordDecl(hasName("A"), has(recordDecl(hasName("B")))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000757
758 EXPECT_TRUE(
759 matches("class A { public: A *a; class B {}; };", TypeAHasClassB));
760}
761
Manuel Klimek4da21662012-07-06 05:48:52 +0000762TEST(Matcher, BindMatchedNodes) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000763 DeclarationMatcher ClassX = has(recordDecl(hasName("::X")).bind("x"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000764
765 EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
Daniel Jaspera7564432012-09-13 13:11:25 +0000766 ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("x")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000767
768 EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
Daniel Jaspera7564432012-09-13 13:11:25 +0000769 ClassX, new VerifyIdIsBoundTo<CXXRecordDecl>("other-id")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000770
771 TypeMatcher TypeAHasClassB = hasDeclaration(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000772 recordDecl(hasName("A"), has(recordDecl(hasName("B")).bind("b"))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000773
774 EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
775 TypeAHasClassB,
Daniel Jaspera7564432012-09-13 13:11:25 +0000776 new VerifyIdIsBoundTo<Decl>("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000777
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000778 StatementMatcher MethodX =
779 callExpr(callee(methodDecl(hasName("x")))).bind("x");
Manuel Klimek4da21662012-07-06 05:48:52 +0000780
781 EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
782 MethodX,
Daniel Jaspera7564432012-09-13 13:11:25 +0000783 new VerifyIdIsBoundTo<CXXMemberCallExpr>("x")));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000784}
785
786TEST(Matcher, BindTheSameNameInAlternatives) {
787 StatementMatcher matcher = anyOf(
788 binaryOperator(hasOperatorName("+"),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000789 hasLHS(expr().bind("x")),
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000790 hasRHS(integerLiteral(equals(0)))),
791 binaryOperator(hasOperatorName("+"),
792 hasLHS(integerLiteral(equals(0))),
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000793 hasRHS(expr().bind("x"))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000794
795 EXPECT_TRUE(matchAndVerifyResultTrue(
796 // The first branch of the matcher binds x to 0 but then fails.
797 // The second branch binds x to f() and succeeds.
798 "int f() { return 0 + f(); }",
799 matcher,
Daniel Jaspera7564432012-09-13 13:11:25 +0000800 new VerifyIdIsBoundTo<CallExpr>("x")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000801}
802
Manuel Klimek66341c52012-08-30 19:41:06 +0000803TEST(Matcher, BindsIDForMemoizedResults) {
804 // Using the same matcher in two match expressions will make memoization
805 // kick in.
806 DeclarationMatcher ClassX = recordDecl(hasName("X")).bind("x");
807 EXPECT_TRUE(matchAndVerifyResultTrue(
808 "class A { class B { class X {}; }; };",
809 DeclarationMatcher(anyOf(
810 recordDecl(hasName("A"), hasDescendant(ClassX)),
811 recordDecl(hasName("B"), hasDescendant(ClassX)))),
Daniel Jaspera7564432012-09-13 13:11:25 +0000812 new VerifyIdIsBoundTo<Decl>("x", 2)));
Manuel Klimek66341c52012-08-30 19:41:06 +0000813}
814
Daniel Jasper189f2e42012-12-03 15:43:25 +0000815TEST(HasDeclaration, HasDeclarationOfEnumType) {
816 EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
817 expr(hasType(pointsTo(
818 qualType(hasDeclaration(enumDecl(hasName("X")))))))));
819}
820
Edwin Vaneb45083d2013-02-25 14:32:42 +0000821TEST(HasDeclaration, HasGetDeclTraitTest) {
822 EXPECT_TRUE(internal::has_getDecl<TypedefType>::value);
823 EXPECT_TRUE(internal::has_getDecl<RecordType>::value);
824 EXPECT_FALSE(internal::has_getDecl<TemplateSpecializationType>::value);
825}
826
Edwin Vane52380602013-02-19 17:14:34 +0000827TEST(HasDeclaration, HasDeclarationOfTypeWithDecl) {
828 EXPECT_TRUE(matches("typedef int X; X a;",
829 varDecl(hasName("a"),
830 hasType(typedefType(hasDeclaration(decl()))))));
831
832 // FIXME: Add tests for other types with getDecl() (e.g. RecordType)
833}
834
Edwin Vane3abf7782013-02-25 14:49:29 +0000835TEST(HasDeclaration, HasDeclarationOfTemplateSpecializationType) {
836 EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
837 varDecl(hasType(templateSpecializationType(
838 hasDeclaration(namedDecl(hasName("A"))))))));
839}
840
Manuel Klimek4da21662012-07-06 05:48:52 +0000841TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000842 TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000843 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000844 matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000845 EXPECT_TRUE(
846 notMatches("class X {}; void y(X *x) { x; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000847 expr(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000848 EXPECT_TRUE(
849 matches("class X {}; void y(X *x) { x; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000850 expr(hasType(pointsTo(ClassX)))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000851}
852
853TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000854 TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
Manuel Klimek4da21662012-07-06 05:48:52 +0000855 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000856 matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000857 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000858 notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000859 EXPECT_TRUE(
860 matches("class X {}; void y() { X *x; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000861 varDecl(hasType(pointsTo(ClassX)))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000862}
863
864TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000865 DeclarationMatcher ClassX = recordDecl(hasName("X"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000866 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000867 matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000868 EXPECT_TRUE(
869 notMatches("class X {}; void y(X *x) { x; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000870 expr(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000871}
872
873TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000874 DeclarationMatcher ClassX = recordDecl(hasName("X"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000875 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000876 matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000877 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000878 notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000879}
880
881TEST(Matcher, Call) {
882 // FIXME: Do we want to overload Call() to directly take
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000883 // Matcher<Decl>, too?
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000884 StatementMatcher MethodX = callExpr(hasDeclaration(methodDecl(hasName("x"))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000885
886 EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
887 EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
888
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000889 StatementMatcher MethodOnY =
890 memberCallExpr(on(hasType(recordDecl(hasName("Y")))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000891
892 EXPECT_TRUE(
893 matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
894 MethodOnY));
895 EXPECT_TRUE(
896 matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
897 MethodOnY));
898 EXPECT_TRUE(
899 notMatches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
900 MethodOnY));
901 EXPECT_TRUE(
902 notMatches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
903 MethodOnY));
904 EXPECT_TRUE(
905 notMatches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
906 MethodOnY));
907
908 StatementMatcher MethodOnYPointer =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000909 memberCallExpr(on(hasType(pointsTo(recordDecl(hasName("Y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +0000910
911 EXPECT_TRUE(
912 matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
913 MethodOnYPointer));
914 EXPECT_TRUE(
915 matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
916 MethodOnYPointer));
917 EXPECT_TRUE(
918 matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
919 MethodOnYPointer));
920 EXPECT_TRUE(
921 notMatches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
922 MethodOnYPointer));
923 EXPECT_TRUE(
924 notMatches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
925 MethodOnYPointer));
926}
927
Daniel Jasper31f7c082012-10-01 13:40:41 +0000928TEST(Matcher, Lambda) {
929 EXPECT_TRUE(matches("auto f = [&] (int i) { return i; };",
930 lambdaExpr()));
931}
932
933TEST(Matcher, ForRange) {
Daniel Jasper1a00fee2012-10-01 15:05:34 +0000934 EXPECT_TRUE(matches("int as[] = { 1, 2, 3 };"
935 "void f() { for (auto &a : as); }",
Daniel Jasper31f7c082012-10-01 13:40:41 +0000936 forRangeStmt()));
937 EXPECT_TRUE(notMatches("void f() { for (int i; i<5; ++i); }",
938 forRangeStmt()));
939}
940
941TEST(Matcher, UserDefinedLiteral) {
942 EXPECT_TRUE(matches("constexpr char operator \"\" _inc (const char i) {"
943 " return i + 1;"
944 "}"
945 "char c = 'a'_inc;",
946 userDefinedLiteral()));
947}
948
Daniel Jasperb54b7642012-09-20 14:12:57 +0000949TEST(Matcher, FlowControl) {
950 EXPECT_TRUE(matches("void f() { while(true) { break; } }", breakStmt()));
951 EXPECT_TRUE(matches("void f() { while(true) { continue; } }",
952 continueStmt()));
953 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", gotoStmt()));
954 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", labelStmt()));
955 EXPECT_TRUE(matches("void f() { return; }", returnStmt()));
956}
957
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000958TEST(HasType, MatchesAsString) {
959 EXPECT_TRUE(
960 matches("class Y { public: void x(); }; void z() {Y* y; y->x(); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000961 memberCallExpr(on(hasType(asString("class Y *"))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000962 EXPECT_TRUE(matches("class X { void x(int x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000963 methodDecl(hasParameter(0, hasType(asString("int"))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000964 EXPECT_TRUE(matches("namespace ns { struct A {}; } struct B { ns::A a; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000965 fieldDecl(hasType(asString("ns::A")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000966 EXPECT_TRUE(matches("namespace { struct A {}; } struct B { A a; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000967 fieldDecl(hasType(asString("struct <anonymous>::A")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +0000968}
969
Manuel Klimek4da21662012-07-06 05:48:52 +0000970TEST(Matcher, OverloadedOperatorCall) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000971 StatementMatcher OpCall = operatorCallExpr();
Manuel Klimek4da21662012-07-06 05:48:52 +0000972 // Unary operator
973 EXPECT_TRUE(matches("class Y { }; "
974 "bool operator!(Y x) { return false; }; "
975 "Y y; bool c = !y;", OpCall));
976 // No match -- special operators like "new", "delete"
977 // FIXME: operator new takes size_t, for which we need stddef.h, for which
978 // we need to figure out include paths in the test.
979 // EXPECT_TRUE(NotMatches("#include <stddef.h>\n"
980 // "class Y { }; "
981 // "void *operator new(size_t size) { return 0; } "
982 // "Y *y = new Y;", OpCall));
983 EXPECT_TRUE(notMatches("class Y { }; "
984 "void operator delete(void *p) { } "
985 "void a() {Y *y = new Y; delete y;}", OpCall));
986 // Binary operator
987 EXPECT_TRUE(matches("class Y { }; "
988 "bool operator&&(Y x, Y y) { return true; }; "
989 "Y a; Y b; bool c = a && b;",
990 OpCall));
991 // No match -- normal operator, not an overloaded one.
992 EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
993 EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
994}
995
996TEST(Matcher, HasOperatorNameForOverloadedOperatorCall) {
997 StatementMatcher OpCallAndAnd =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +0000998 operatorCallExpr(hasOverloadedOperatorName("&&"));
Manuel Klimek4da21662012-07-06 05:48:52 +0000999 EXPECT_TRUE(matches("class Y { }; "
1000 "bool operator&&(Y x, Y y) { return true; }; "
1001 "Y a; Y b; bool c = a && b;", OpCallAndAnd));
1002 StatementMatcher OpCallLessLess =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001003 operatorCallExpr(hasOverloadedOperatorName("<<"));
Manuel Klimek4da21662012-07-06 05:48:52 +00001004 EXPECT_TRUE(notMatches("class Y { }; "
1005 "bool operator&&(Y x, Y y) { return true; }; "
1006 "Y a; Y b; bool c = a && b;",
1007 OpCallLessLess));
1008}
1009
Daniel Jasper278057f2012-11-15 03:29:05 +00001010TEST(Matcher, NestedOverloadedOperatorCalls) {
1011 EXPECT_TRUE(matchAndVerifyResultTrue(
1012 "class Y { }; "
1013 "Y& operator&&(Y& x, Y& y) { return x; }; "
1014 "Y a; Y b; Y c; Y d = a && b && c;",
1015 operatorCallExpr(hasOverloadedOperatorName("&&")).bind("x"),
1016 new VerifyIdIsBoundTo<CXXOperatorCallExpr>("x", 2)));
1017 EXPECT_TRUE(matches(
1018 "class Y { }; "
1019 "Y& operator&&(Y& x, Y& y) { return x; }; "
1020 "Y a; Y b; Y c; Y d = a && b && c;",
1021 operatorCallExpr(hasParent(operatorCallExpr()))));
1022 EXPECT_TRUE(matches(
1023 "class Y { }; "
1024 "Y& operator&&(Y& x, Y& y) { return x; }; "
1025 "Y a; Y b; Y c; Y d = a && b && c;",
1026 operatorCallExpr(hasDescendant(operatorCallExpr()))));
1027}
1028
Manuel Klimek4da21662012-07-06 05:48:52 +00001029TEST(Matcher, ThisPointerType) {
Manuel Klimek9f174082012-07-24 13:37:29 +00001030 StatementMatcher MethodOnY =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001031 memberCallExpr(thisPointerType(recordDecl(hasName("Y"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001032
1033 EXPECT_TRUE(
1034 matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
1035 MethodOnY));
1036 EXPECT_TRUE(
1037 matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
1038 MethodOnY));
1039 EXPECT_TRUE(
1040 matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
1041 MethodOnY));
1042 EXPECT_TRUE(
1043 matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
1044 MethodOnY));
1045 EXPECT_TRUE(
1046 matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
1047 MethodOnY));
1048
1049 EXPECT_TRUE(matches(
1050 "class Y {"
1051 " public: virtual void x();"
1052 "};"
1053 "class X : public Y {"
1054 " public: virtual void x();"
1055 "};"
1056 "void z() { X *x; x->Y::x(); }", MethodOnY));
1057}
1058
1059TEST(Matcher, VariableUsage) {
1060 StatementMatcher Reference =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001061 declRefExpr(to(
1062 varDecl(hasInitializer(
1063 memberCallExpr(thisPointerType(recordDecl(hasName("Y"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001064
1065 EXPECT_TRUE(matches(
1066 "class Y {"
1067 " public:"
1068 " bool x() const;"
1069 "};"
1070 "void z(const Y &y) {"
1071 " bool b = y.x();"
1072 " if (b) {}"
1073 "}", Reference));
1074
1075 EXPECT_TRUE(notMatches(
1076 "class Y {"
1077 " public:"
1078 " bool x() const;"
1079 "};"
1080 "void z(const Y &y) {"
1081 " bool b = y.x();"
1082 "}", Reference));
1083}
1084
Manuel Klimek8cb9bf52012-12-04 14:42:08 +00001085TEST(Matcher, FindsVarDeclInFunctionParameter) {
Daniel Jasper9bd28092012-07-30 05:03:25 +00001086 EXPECT_TRUE(matches(
1087 "void f(int i) {}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001088 varDecl(hasName("i"))));
Daniel Jasper9bd28092012-07-30 05:03:25 +00001089}
1090
Manuel Klimek4da21662012-07-06 05:48:52 +00001091TEST(Matcher, CalledVariable) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001092 StatementMatcher CallOnVariableY =
1093 memberCallExpr(on(declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001094
1095 EXPECT_TRUE(matches(
1096 "class Y { public: void x() { Y y; y.x(); } };", CallOnVariableY));
1097 EXPECT_TRUE(matches(
1098 "class Y { public: void x() const { Y y; y.x(); } };", CallOnVariableY));
1099 EXPECT_TRUE(matches(
1100 "class Y { public: void x(); };"
1101 "class X : public Y { void z() { X y; y.x(); } };", CallOnVariableY));
1102 EXPECT_TRUE(matches(
1103 "class Y { public: void x(); };"
1104 "class X : public Y { void z() { X *y; y->x(); } };", CallOnVariableY));
1105 EXPECT_TRUE(notMatches(
1106 "class Y { public: void x(); };"
1107 "class X : public Y { void z() { unsigned long y; ((X*)y)->x(); } };",
1108 CallOnVariableY));
1109}
1110
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001111TEST(UnaryExprOrTypeTraitExpr, MatchesSizeOfAndAlignOf) {
1112 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }",
1113 unaryExprOrTypeTraitExpr()));
1114 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }",
1115 alignOfExpr(anything())));
1116 // FIXME: Uncomment once alignof is enabled.
1117 // EXPECT_TRUE(matches("void x() { int a = alignof(a); }",
1118 // unaryExprOrTypeTraitExpr()));
1119 // EXPECT_TRUE(notMatches("void x() { int a = alignof(a); }",
1120 // sizeOfExpr()));
1121}
1122
1123TEST(UnaryExpressionOrTypeTraitExpression, MatchesCorrectType) {
1124 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }", sizeOfExpr(
1125 hasArgumentOfType(asString("int")))));
1126 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
1127 hasArgumentOfType(asString("float")))));
1128 EXPECT_TRUE(matches(
1129 "struct A {}; void x() { A a; int b = sizeof(a); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001130 sizeOfExpr(hasArgumentOfType(hasDeclaration(recordDecl(hasName("A")))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001131 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001132 hasArgumentOfType(hasDeclaration(recordDecl(hasName("string")))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001133}
1134
Manuel Klimek4da21662012-07-06 05:48:52 +00001135TEST(MemberExpression, DoesNotMatchClasses) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001136 EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001137}
1138
1139TEST(MemberExpression, MatchesMemberFunctionCall) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001140 EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001141}
1142
1143TEST(MemberExpression, MatchesVariable) {
1144 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001145 matches("class Y { void x() { this->y; } int y; };", memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001146 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001147 matches("class Y { void x() { y; } int y; };", memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001148 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001149 matches("class Y { void x() { Y y; y.y; } int y; };", memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001150}
1151
1152TEST(MemberExpression, MatchesStaticVariable) {
1153 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001154 memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001155 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001156 memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001157 EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001158 memberExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00001159}
1160
Daniel Jasper6a124492012-07-12 08:50:38 +00001161TEST(IsInteger, MatchesIntegers) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001162 EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isInteger()))));
1163 EXPECT_TRUE(matches(
1164 "long long i = 0; void f(long long) { }; void g() {f(i);}",
1165 callExpr(hasArgument(0, declRefExpr(
1166 to(varDecl(hasType(isInteger()))))))));
Daniel Jasper6a124492012-07-12 08:50:38 +00001167}
1168
1169TEST(IsInteger, ReportsNoFalsePositives) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001170 EXPECT_TRUE(notMatches("int *i;", varDecl(hasType(isInteger()))));
Daniel Jasper6a124492012-07-12 08:50:38 +00001171 EXPECT_TRUE(notMatches("struct T {}; T t; void f(T *) { }; void g() {f(&t);}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001172 callExpr(hasArgument(0, declRefExpr(
1173 to(varDecl(hasType(isInteger()))))))));
Daniel Jasper6a124492012-07-12 08:50:38 +00001174}
1175
Manuel Klimek4da21662012-07-06 05:48:52 +00001176TEST(IsArrow, MatchesMemberVariablesViaArrow) {
1177 EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001178 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001179 EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001180 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001181 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001182 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001183}
1184
1185TEST(IsArrow, MatchesStaticMemberVariablesViaArrow) {
1186 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001187 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001188 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001189 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001190 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001191 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001192}
1193
1194TEST(IsArrow, MatchesMemberCallsViaArrow) {
1195 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001196 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001197 EXPECT_TRUE(matches("class Y { void x() { x(); } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001198 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001199 EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001200 memberExpr(isArrow())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001201}
1202
1203TEST(Callee, MatchesDeclarations) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001204 StatementMatcher CallMethodX = callExpr(callee(methodDecl(hasName("x"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001205
1206 EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
1207 EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
1208}
1209
1210TEST(Callee, MatchesMemberExpressions) {
1211 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001212 callExpr(callee(memberExpr()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001213 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001214 notMatches("class Y { void x() { this->x(); } };", callExpr(callee(callExpr()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001215}
1216
1217TEST(Function, MatchesFunctionDeclarations) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001218 StatementMatcher CallFunctionF = callExpr(callee(functionDecl(hasName("f"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001219
1220 EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
1221 EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
1222
Manuel Klimeke265c872012-07-10 14:21:30 +00001223#if !defined(_MSC_VER)
1224 // FIXME: Make this work for MSVC.
Manuel Klimek4da21662012-07-06 05:48:52 +00001225 // Dependent contexts, but a non-dependent call.
1226 EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
1227 CallFunctionF));
1228 EXPECT_TRUE(
1229 matches("void f(); template <int N> struct S { void g() { f(); } };",
1230 CallFunctionF));
Manuel Klimeke265c872012-07-10 14:21:30 +00001231#endif
Manuel Klimek4da21662012-07-06 05:48:52 +00001232
1233 // Depedent calls don't match.
1234 EXPECT_TRUE(
1235 notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
1236 CallFunctionF));
1237 EXPECT_TRUE(
1238 notMatches("void f(int);"
1239 "template <typename T> struct S { void g(T t) { f(t); } };",
1240 CallFunctionF));
1241}
1242
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00001243TEST(FunctionTemplate, MatchesFunctionTemplateDeclarations) {
1244 EXPECT_TRUE(
1245 matches("template <typename T> void f(T t) {}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001246 functionTemplateDecl(hasName("f"))));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00001247}
1248
1249TEST(FunctionTemplate, DoesNotMatchFunctionDeclarations) {
1250 EXPECT_TRUE(
1251 notMatches("void f(double d); void f(int t) {}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001252 functionTemplateDecl(hasName("f"))));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00001253}
1254
1255TEST(FunctionTemplate, DoesNotMatchFunctionTemplateSpecializations) {
1256 EXPECT_TRUE(
1257 notMatches("void g(); template <typename T> void f(T t) {}"
1258 "template <> void f(int t) { g(); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001259 functionTemplateDecl(hasName("f"),
1260 hasDescendant(declRefExpr(to(
1261 functionDecl(hasName("g"))))))));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00001262}
1263
Manuel Klimek4da21662012-07-06 05:48:52 +00001264TEST(Matcher, Argument) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001265 StatementMatcher CallArgumentY = callExpr(
1266 hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001267
1268 EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
1269 EXPECT_TRUE(
1270 matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
1271 EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
1272
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001273 StatementMatcher WrongIndex = callExpr(
1274 hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001275 EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
1276}
1277
1278TEST(Matcher, AnyArgument) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001279 StatementMatcher CallArgumentY = callExpr(
1280 hasAnyArgument(declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001281 EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
1282 EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
1283 EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
1284}
1285
1286TEST(Matcher, ArgumentCount) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001287 StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
Manuel Klimek4da21662012-07-06 05:48:52 +00001288
1289 EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
1290 EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
1291 EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
1292}
1293
Daniel Jasper36e29d62012-12-04 11:54:27 +00001294TEST(Matcher, ParameterCount) {
1295 DeclarationMatcher Function1Arg = functionDecl(parameterCountIs(1));
1296 EXPECT_TRUE(matches("void f(int i) {}", Function1Arg));
1297 EXPECT_TRUE(matches("class X { void f(int i) {} };", Function1Arg));
1298 EXPECT_TRUE(notMatches("void f() {}", Function1Arg));
1299 EXPECT_TRUE(notMatches("void f(int i, int j, int k) {}", Function1Arg));
1300}
1301
Manuel Klimek4da21662012-07-06 05:48:52 +00001302TEST(Matcher, References) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001303 DeclarationMatcher ReferenceClassX = varDecl(
1304 hasType(references(recordDecl(hasName("X")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001305 EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
1306 ReferenceClassX));
1307 EXPECT_TRUE(
1308 matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
1309 EXPECT_TRUE(
1310 notMatches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
1311 EXPECT_TRUE(
1312 notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
1313}
1314
1315TEST(HasParameter, CallsInnerMatcher) {
1316 EXPECT_TRUE(matches("class X { void x(int) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001317 methodDecl(hasParameter(0, varDecl()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001318 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001319 methodDecl(hasParameter(0, hasName("x")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001320}
1321
1322TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
1323 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001324 methodDecl(hasParameter(42, varDecl()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001325}
1326
1327TEST(HasType, MatchesParameterVariableTypesStrictly) {
1328 EXPECT_TRUE(matches("class X { void x(X x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001329 methodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001330 EXPECT_TRUE(notMatches("class X { void x(const X &x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001331 methodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001332 EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001333 methodDecl(hasParameter(0,
1334 hasType(pointsTo(recordDecl(hasName("X"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001335 EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001336 methodDecl(hasParameter(0,
1337 hasType(references(recordDecl(hasName("X"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001338}
1339
1340TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
1341 EXPECT_TRUE(matches("class Y {}; class X { void x(X x, Y y) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001342 methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001343 EXPECT_TRUE(matches("class Y {}; class X { void x(Y y, X x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001344 methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001345}
1346
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001347TEST(Returns, MatchesReturnTypes) {
1348 EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001349 functionDecl(returns(asString("int")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001350 EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001351 functionDecl(returns(asString("float")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001352 EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001353 functionDecl(returns(hasDeclaration(
1354 recordDecl(hasName("Y")))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001355}
1356
Daniel Jasper8cc7efa2012-08-15 18:52:19 +00001357TEST(IsExternC, MatchesExternCFunctionDeclarations) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001358 EXPECT_TRUE(matches("extern \"C\" void f() {}", functionDecl(isExternC())));
1359 EXPECT_TRUE(matches("extern \"C\" { void f() {} }",
1360 functionDecl(isExternC())));
1361 EXPECT_TRUE(notMatches("void f() {}", functionDecl(isExternC())));
Daniel Jasper8cc7efa2012-08-15 18:52:19 +00001362}
1363
Manuel Klimek4da21662012-07-06 05:48:52 +00001364TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
1365 EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001366 methodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001367}
1368
1369TEST(HasAnyParameter, DoesNotMatchThisPointer) {
1370 EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001371 methodDecl(hasAnyParameter(hasType(pointsTo(
1372 recordDecl(hasName("X"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001373}
1374
1375TEST(HasName, MatchesParameterVariableDeclartions) {
1376 EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001377 methodDecl(hasAnyParameter(hasName("x")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001378 EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001379 methodDecl(hasAnyParameter(hasName("x")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001380}
1381
Daniel Jasper371f9392012-08-01 08:40:24 +00001382TEST(Matcher, MatchesClassTemplateSpecialization) {
1383 EXPECT_TRUE(matches("template<typename T> struct A {};"
1384 "template<> struct A<int> {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001385 classTemplateSpecializationDecl()));
Daniel Jasper371f9392012-08-01 08:40:24 +00001386 EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001387 classTemplateSpecializationDecl()));
Daniel Jasper371f9392012-08-01 08:40:24 +00001388 EXPECT_TRUE(notMatches("template<typename T> struct A {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001389 classTemplateSpecializationDecl()));
Daniel Jasper371f9392012-08-01 08:40:24 +00001390}
1391
1392TEST(Matcher, MatchesTypeTemplateArgument) {
1393 EXPECT_TRUE(matches(
1394 "template<typename T> struct B {};"
1395 "B<int> b;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001396 classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
Daniel Jasper371f9392012-08-01 08:40:24 +00001397 asString("int"))))));
1398}
1399
1400TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
1401 EXPECT_TRUE(matches(
1402 "struct B { int next; };"
1403 "template<int(B::*next_ptr)> struct A {};"
1404 "A<&B::next> a;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001405 classTemplateSpecializationDecl(hasAnyTemplateArgument(
1406 refersToDeclaration(fieldDecl(hasName("next")))))));
Daniel Jasperaaa8e452012-09-29 15:55:18 +00001407
1408 EXPECT_TRUE(notMatches(
1409 "template <typename T> struct A {};"
1410 "A<int> a;",
1411 classTemplateSpecializationDecl(hasAnyTemplateArgument(
1412 refersToDeclaration(decl())))));
Daniel Jasper371f9392012-08-01 08:40:24 +00001413}
1414
1415TEST(Matcher, MatchesSpecificArgument) {
1416 EXPECT_TRUE(matches(
1417 "template<typename T, typename U> class A {};"
1418 "A<bool, int> a;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001419 classTemplateSpecializationDecl(hasTemplateArgument(
Daniel Jasper371f9392012-08-01 08:40:24 +00001420 1, refersToType(asString("int"))))));
1421 EXPECT_TRUE(notMatches(
1422 "template<typename T, typename U> class A {};"
1423 "A<int, bool> a;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001424 classTemplateSpecializationDecl(hasTemplateArgument(
Daniel Jasper371f9392012-08-01 08:40:24 +00001425 1, refersToType(asString("int"))))));
1426}
1427
Daniel Jasperf3197e92013-02-25 12:02:08 +00001428TEST(Matcher, MatchesAccessSpecDecls) {
1429 EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));
1430 EXPECT_TRUE(
1431 matches("class C { public: int i; };", accessSpecDecl(isPublic())));
1432 EXPECT_TRUE(
1433 notMatches("class C { public: int i; };", accessSpecDecl(isProtected())));
1434 EXPECT_TRUE(
1435 notMatches("class C { public: int i; };", accessSpecDecl(isPrivate())));
1436
1437 EXPECT_TRUE(notMatches("class C { int i; };", accessSpecDecl()));
1438}
1439
Manuel Klimek4da21662012-07-06 05:48:52 +00001440TEST(Matcher, ConstructorCall) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001441 StatementMatcher Constructor = constructExpr();
Manuel Klimek4da21662012-07-06 05:48:52 +00001442
1443 EXPECT_TRUE(
1444 matches("class X { public: X(); }; void x() { X x; }", Constructor));
1445 EXPECT_TRUE(
1446 matches("class X { public: X(); }; void x() { X x = X(); }",
1447 Constructor));
1448 EXPECT_TRUE(
1449 matches("class X { public: X(int); }; void x() { X x = 0; }",
1450 Constructor));
1451 EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
1452}
1453
1454TEST(Matcher, ConstructorArgument) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001455 StatementMatcher Constructor = constructExpr(
1456 hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001457
1458 EXPECT_TRUE(
1459 matches("class X { public: X(int); }; void x() { int y; X x(y); }",
1460 Constructor));
1461 EXPECT_TRUE(
1462 matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
1463 Constructor));
1464 EXPECT_TRUE(
1465 matches("class X { public: X(int); }; void x() { int y; X x = y; }",
1466 Constructor));
1467 EXPECT_TRUE(
1468 notMatches("class X { public: X(int); }; void x() { int z; X x(z); }",
1469 Constructor));
1470
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001471 StatementMatcher WrongIndex = constructExpr(
1472 hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001473 EXPECT_TRUE(
1474 notMatches("class X { public: X(int); }; void x() { int y; X x(y); }",
1475 WrongIndex));
1476}
1477
1478TEST(Matcher, ConstructorArgumentCount) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001479 StatementMatcher Constructor1Arg = constructExpr(argumentCountIs(1));
Manuel Klimek4da21662012-07-06 05:48:52 +00001480
1481 EXPECT_TRUE(
1482 matches("class X { public: X(int); }; void x() { X x(0); }",
1483 Constructor1Arg));
1484 EXPECT_TRUE(
1485 matches("class X { public: X(int); }; void x() { X x = X(0); }",
1486 Constructor1Arg));
1487 EXPECT_TRUE(
1488 matches("class X { public: X(int); }; void x() { X x = 0; }",
1489 Constructor1Arg));
1490 EXPECT_TRUE(
1491 notMatches("class X { public: X(int, int); }; void x() { X x(0, 0); }",
1492 Constructor1Arg));
1493}
1494
Manuel Klimek70b9db92012-10-23 10:40:50 +00001495TEST(Matcher,ThisExpr) {
1496 EXPECT_TRUE(
1497 matches("struct X { int a; int f () { return a; } };", thisExpr()));
1498 EXPECT_TRUE(
1499 notMatches("struct X { int f () { int a; return a; } };", thisExpr()));
1500}
1501
Manuel Klimek4da21662012-07-06 05:48:52 +00001502TEST(Matcher, BindTemporaryExpression) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001503 StatementMatcher TempExpression = bindTemporaryExpr();
Manuel Klimek4da21662012-07-06 05:48:52 +00001504
1505 std::string ClassString = "class string { public: string(); ~string(); }; ";
1506
1507 EXPECT_TRUE(
1508 matches(ClassString +
1509 "string GetStringByValue();"
1510 "void FunctionTakesString(string s);"
1511 "void run() { FunctionTakesString(GetStringByValue()); }",
1512 TempExpression));
1513
1514 EXPECT_TRUE(
1515 notMatches(ClassString +
1516 "string* GetStringPointer(); "
1517 "void FunctionTakesStringPtr(string* s);"
1518 "void run() {"
1519 " string* s = GetStringPointer();"
1520 " FunctionTakesStringPtr(GetStringPointer());"
1521 " FunctionTakesStringPtr(s);"
1522 "}",
1523 TempExpression));
1524
1525 EXPECT_TRUE(
1526 notMatches("class no_dtor {};"
1527 "no_dtor GetObjByValue();"
1528 "void ConsumeObj(no_dtor param);"
1529 "void run() { ConsumeObj(GetObjByValue()); }",
1530 TempExpression));
1531}
1532
Sam Panzere16acd32012-08-24 22:04:44 +00001533TEST(MaterializeTemporaryExpr, MatchesTemporary) {
1534 std::string ClassString =
1535 "class string { public: string(); int length(); }; ";
1536
1537 EXPECT_TRUE(
1538 matches(ClassString +
1539 "string GetStringByValue();"
1540 "void FunctionTakesString(string s);"
1541 "void run() { FunctionTakesString(GetStringByValue()); }",
1542 materializeTemporaryExpr()));
1543
1544 EXPECT_TRUE(
1545 notMatches(ClassString +
1546 "string* GetStringPointer(); "
1547 "void FunctionTakesStringPtr(string* s);"
1548 "void run() {"
1549 " string* s = GetStringPointer();"
1550 " FunctionTakesStringPtr(GetStringPointer());"
1551 " FunctionTakesStringPtr(s);"
1552 "}",
1553 materializeTemporaryExpr()));
1554
1555 EXPECT_TRUE(
1556 notMatches(ClassString +
1557 "string GetStringByValue();"
1558 "void run() { int k = GetStringByValue().length(); }",
1559 materializeTemporaryExpr()));
1560
1561 EXPECT_TRUE(
1562 notMatches(ClassString +
1563 "string GetStringByValue();"
1564 "void run() { GetStringByValue(); }",
1565 materializeTemporaryExpr()));
1566}
1567
Manuel Klimek4da21662012-07-06 05:48:52 +00001568TEST(ConstructorDeclaration, SimpleCase) {
1569 EXPECT_TRUE(matches("class Foo { Foo(int i); };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001570 constructorDecl(ofClass(hasName("Foo")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001571 EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001572 constructorDecl(ofClass(hasName("Bar")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001573}
1574
1575TEST(ConstructorDeclaration, IsImplicit) {
1576 // This one doesn't match because the constructor is not added by the
1577 // compiler (it is not needed).
1578 EXPECT_TRUE(notMatches("class Foo { };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001579 constructorDecl(isImplicit())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001580 // The compiler added the implicit default constructor.
1581 EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001582 constructorDecl(isImplicit())));
Manuel Klimek4da21662012-07-06 05:48:52 +00001583 EXPECT_TRUE(matches("class Foo { Foo(){} };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001584 constructorDecl(unless(isImplicit()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001585}
1586
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001587TEST(DestructorDeclaration, MatchesVirtualDestructor) {
1588 EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001589 destructorDecl(ofClass(hasName("Foo")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001590}
1591
1592TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001593 EXPECT_TRUE(notMatches("class Foo {};",
1594 destructorDecl(ofClass(hasName("Foo")))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001595}
1596
Manuel Klimek4da21662012-07-06 05:48:52 +00001597TEST(HasAnyConstructorInitializer, SimpleCase) {
1598 EXPECT_TRUE(notMatches(
1599 "class Foo { Foo() { } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001600 constructorDecl(hasAnyConstructorInitializer(anything()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001601 EXPECT_TRUE(matches(
1602 "class Foo {"
1603 " Foo() : foo_() { }"
1604 " int foo_;"
1605 "};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001606 constructorDecl(hasAnyConstructorInitializer(anything()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001607}
1608
1609TEST(HasAnyConstructorInitializer, ForField) {
1610 static const char Code[] =
1611 "class Baz { };"
1612 "class Foo {"
1613 " Foo() : foo_() { }"
1614 " Baz foo_;"
1615 " Baz bar_;"
1616 "};";
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001617 EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
1618 forField(hasType(recordDecl(hasName("Baz"))))))));
1619 EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001620 forField(hasName("foo_"))))));
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001621 EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
1622 forField(hasType(recordDecl(hasName("Bar"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001623}
1624
1625TEST(HasAnyConstructorInitializer, WithInitializer) {
1626 static const char Code[] =
1627 "class Foo {"
1628 " Foo() : foo_(0) { }"
1629 " int foo_;"
1630 "};";
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001631 EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001632 withInitializer(integerLiteral(equals(0)))))));
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001633 EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001634 withInitializer(integerLiteral(equals(1)))))));
1635}
1636
1637TEST(HasAnyConstructorInitializer, IsWritten) {
1638 static const char Code[] =
1639 "struct Bar { Bar(){} };"
1640 "class Foo {"
1641 " Foo() : foo_() { }"
1642 " Bar foo_;"
1643 " Bar bar_;"
1644 "};";
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001645 EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001646 allOf(forField(hasName("foo_")), isWritten())))));
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001647 EXPECT_TRUE(notMatches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001648 allOf(forField(hasName("bar_")), isWritten())))));
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001649 EXPECT_TRUE(matches(Code, constructorDecl(hasAnyConstructorInitializer(
Manuel Klimek4da21662012-07-06 05:48:52 +00001650 allOf(forField(hasName("bar_")), unless(isWritten()))))));
1651}
1652
1653TEST(Matcher, NewExpression) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001654 StatementMatcher New = newExpr();
Manuel Klimek4da21662012-07-06 05:48:52 +00001655
1656 EXPECT_TRUE(matches("class X { public: X(); }; void x() { new X; }", New));
1657 EXPECT_TRUE(
1658 matches("class X { public: X(); }; void x() { new X(); }", New));
1659 EXPECT_TRUE(
1660 matches("class X { public: X(int); }; void x() { new X(0); }", New));
1661 EXPECT_TRUE(matches("class X {}; void x(int) { new X; }", New));
1662}
1663
1664TEST(Matcher, NewExpressionArgument) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001665 StatementMatcher New = constructExpr(
1666 hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001667
1668 EXPECT_TRUE(
1669 matches("class X { public: X(int); }; void x() { int y; new X(y); }",
1670 New));
1671 EXPECT_TRUE(
1672 matches("class X { public: X(int); }; void x() { int y; new X(y); }",
1673 New));
1674 EXPECT_TRUE(
1675 notMatches("class X { public: X(int); }; void x() { int z; new X(z); }",
1676 New));
1677
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001678 StatementMatcher WrongIndex = constructExpr(
1679 hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001680 EXPECT_TRUE(
1681 notMatches("class X { public: X(int); }; void x() { int y; new X(y); }",
1682 WrongIndex));
1683}
1684
1685TEST(Matcher, NewExpressionArgumentCount) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001686 StatementMatcher New = constructExpr(argumentCountIs(1));
Manuel Klimek4da21662012-07-06 05:48:52 +00001687
1688 EXPECT_TRUE(
1689 matches("class X { public: X(int); }; void x() { new X(0); }", New));
1690 EXPECT_TRUE(
1691 notMatches("class X { public: X(int, int); }; void x() { new X(0, 0); }",
1692 New));
1693}
1694
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001695TEST(Matcher, DeleteExpression) {
1696 EXPECT_TRUE(matches("struct A {}; void f(A* a) { delete a; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001697 deleteExpr()));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001698}
1699
Manuel Klimek4da21662012-07-06 05:48:52 +00001700TEST(Matcher, DefaultArgument) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001701 StatementMatcher Arg = defaultArgExpr();
Manuel Klimek4da21662012-07-06 05:48:52 +00001702
1703 EXPECT_TRUE(matches("void x(int, int = 0) { int y; x(y); }", Arg));
1704 EXPECT_TRUE(
1705 matches("class X { void x(int, int = 0) { int y; x(y); } };", Arg));
1706 EXPECT_TRUE(notMatches("void x(int, int = 0) { int y; x(y, 0); }", Arg));
1707}
1708
1709TEST(Matcher, StringLiterals) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001710 StatementMatcher Literal = stringLiteral();
Manuel Klimek4da21662012-07-06 05:48:52 +00001711 EXPECT_TRUE(matches("const char *s = \"string\";", Literal));
1712 // wide string
1713 EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", Literal));
1714 // with escaped characters
1715 EXPECT_TRUE(matches("const char *s = \"\x05five\";", Literal));
1716 // no matching -- though the data type is the same, there is no string literal
1717 EXPECT_TRUE(notMatches("const char s[1] = {'a'};", Literal));
1718}
1719
1720TEST(Matcher, CharacterLiterals) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001721 StatementMatcher CharLiteral = characterLiteral();
Manuel Klimek4da21662012-07-06 05:48:52 +00001722 EXPECT_TRUE(matches("const char c = 'c';", CharLiteral));
1723 // wide character
1724 EXPECT_TRUE(matches("const char c = L'c';", CharLiteral));
1725 // wide character, Hex encoded, NOT MATCHED!
1726 EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", CharLiteral));
1727 EXPECT_TRUE(notMatches("const char c = 0x1;", CharLiteral));
1728}
1729
1730TEST(Matcher, IntegerLiterals) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00001731 StatementMatcher HasIntLiteral = integerLiteral();
Manuel Klimek4da21662012-07-06 05:48:52 +00001732 EXPECT_TRUE(matches("int i = 10;", HasIntLiteral));
1733 EXPECT_TRUE(matches("int i = 0x1AB;", HasIntLiteral));
1734 EXPECT_TRUE(matches("int i = 10L;", HasIntLiteral));
1735 EXPECT_TRUE(matches("int i = 10U;", HasIntLiteral));
1736
1737 // Non-matching cases (character literals, float and double)
1738 EXPECT_TRUE(notMatches("int i = L'a';",
1739 HasIntLiteral)); // this is actually a character
1740 // literal cast to int
1741 EXPECT_TRUE(notMatches("int i = 'a';", HasIntLiteral));
1742 EXPECT_TRUE(notMatches("int i = 1e10;", HasIntLiteral));
1743 EXPECT_TRUE(notMatches("int i = 10.0;", HasIntLiteral));
1744}
1745
Daniel Jasper31f7c082012-10-01 13:40:41 +00001746TEST(Matcher, NullPtrLiteral) {
1747 EXPECT_TRUE(matches("int* i = nullptr;", nullPtrLiteralExpr()));
1748}
1749
Daniel Jasperb54b7642012-09-20 14:12:57 +00001750TEST(Matcher, AsmStatement) {
1751 EXPECT_TRUE(matches("void foo() { __asm(\"mov al, 2\"); }", asmStmt()));
1752}
1753
Manuel Klimek4da21662012-07-06 05:48:52 +00001754TEST(Matcher, Conditions) {
1755 StatementMatcher Condition = ifStmt(hasCondition(boolLiteral(equals(true))));
1756
1757 EXPECT_TRUE(matches("void x() { if (true) {} }", Condition));
1758 EXPECT_TRUE(notMatches("void x() { if (false) {} }", Condition));
1759 EXPECT_TRUE(notMatches("void x() { bool a = true; if (a) {} }", Condition));
1760 EXPECT_TRUE(notMatches("void x() { if (true || false) {} }", Condition));
1761 EXPECT_TRUE(notMatches("void x() { if (1) {} }", Condition));
1762}
1763
1764TEST(MatchBinaryOperator, HasOperatorName) {
1765 StatementMatcher OperatorOr = binaryOperator(hasOperatorName("||"));
1766
1767 EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
1768 EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
1769}
1770
1771TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
1772 StatementMatcher OperatorTrueFalse =
1773 binaryOperator(hasLHS(boolLiteral(equals(true))),
1774 hasRHS(boolLiteral(equals(false))));
1775
1776 EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
1777 EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
1778 EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
1779}
1780
1781TEST(MatchBinaryOperator, HasEitherOperand) {
1782 StatementMatcher HasOperand =
1783 binaryOperator(hasEitherOperand(boolLiteral(equals(false))));
1784
1785 EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
1786 EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
1787 EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
1788}
1789
1790TEST(Matcher, BinaryOperatorTypes) {
1791 // Integration test that verifies the AST provides all binary operators in
1792 // a way we expect.
1793 // FIXME: Operator ','
1794 EXPECT_TRUE(
1795 matches("void x() { 3, 4; }", binaryOperator(hasOperatorName(","))));
1796 EXPECT_TRUE(
1797 matches("bool b; bool c = (b = true);",
1798 binaryOperator(hasOperatorName("="))));
1799 EXPECT_TRUE(
1800 matches("bool b = 1 != 2;", binaryOperator(hasOperatorName("!="))));
1801 EXPECT_TRUE(
1802 matches("bool b = 1 == 2;", binaryOperator(hasOperatorName("=="))));
1803 EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
1804 EXPECT_TRUE(
1805 matches("bool b = 1 <= 2;", binaryOperator(hasOperatorName("<="))));
1806 EXPECT_TRUE(
1807 matches("int i = 1 << 2;", binaryOperator(hasOperatorName("<<"))));
1808 EXPECT_TRUE(
1809 matches("int i = 1; int j = (i <<= 2);",
1810 binaryOperator(hasOperatorName("<<="))));
1811 EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
1812 EXPECT_TRUE(
1813 matches("bool b = 1 >= 2;", binaryOperator(hasOperatorName(">="))));
1814 EXPECT_TRUE(
1815 matches("int i = 1 >> 2;", binaryOperator(hasOperatorName(">>"))));
1816 EXPECT_TRUE(
1817 matches("int i = 1; int j = (i >>= 2);",
1818 binaryOperator(hasOperatorName(">>="))));
1819 EXPECT_TRUE(
1820 matches("int i = 42 ^ 23;", binaryOperator(hasOperatorName("^"))));
1821 EXPECT_TRUE(
1822 matches("int i = 42; int j = (i ^= 42);",
1823 binaryOperator(hasOperatorName("^="))));
1824 EXPECT_TRUE(
1825 matches("int i = 42 % 23;", binaryOperator(hasOperatorName("%"))));
1826 EXPECT_TRUE(
1827 matches("int i = 42; int j = (i %= 42);",
1828 binaryOperator(hasOperatorName("%="))));
1829 EXPECT_TRUE(
1830 matches("bool b = 42 &23;", binaryOperator(hasOperatorName("&"))));
1831 EXPECT_TRUE(
1832 matches("bool b = true && false;",
1833 binaryOperator(hasOperatorName("&&"))));
1834 EXPECT_TRUE(
1835 matches("bool b = true; bool c = (b &= false);",
1836 binaryOperator(hasOperatorName("&="))));
1837 EXPECT_TRUE(
1838 matches("bool b = 42 | 23;", binaryOperator(hasOperatorName("|"))));
1839 EXPECT_TRUE(
1840 matches("bool b = true || false;",
1841 binaryOperator(hasOperatorName("||"))));
1842 EXPECT_TRUE(
1843 matches("bool b = true; bool c = (b |= false);",
1844 binaryOperator(hasOperatorName("|="))));
1845 EXPECT_TRUE(
1846 matches("int i = 42 *23;", binaryOperator(hasOperatorName("*"))));
1847 EXPECT_TRUE(
1848 matches("int i = 42; int j = (i *= 23);",
1849 binaryOperator(hasOperatorName("*="))));
1850 EXPECT_TRUE(
1851 matches("int i = 42 / 23;", binaryOperator(hasOperatorName("/"))));
1852 EXPECT_TRUE(
1853 matches("int i = 42; int j = (i /= 23);",
1854 binaryOperator(hasOperatorName("/="))));
1855 EXPECT_TRUE(
1856 matches("int i = 42 + 23;", binaryOperator(hasOperatorName("+"))));
1857 EXPECT_TRUE(
1858 matches("int i = 42; int j = (i += 23);",
1859 binaryOperator(hasOperatorName("+="))));
1860 EXPECT_TRUE(
1861 matches("int i = 42 - 23;", binaryOperator(hasOperatorName("-"))));
1862 EXPECT_TRUE(
1863 matches("int i = 42; int j = (i -= 23);",
1864 binaryOperator(hasOperatorName("-="))));
1865 EXPECT_TRUE(
1866 matches("struct A { void x() { void (A::*a)(); (this->*a)(); } };",
1867 binaryOperator(hasOperatorName("->*"))));
1868 EXPECT_TRUE(
1869 matches("struct A { void x() { void (A::*a)(); ((*this).*a)(); } };",
1870 binaryOperator(hasOperatorName(".*"))));
1871
1872 // Member expressions as operators are not supported in matches.
1873 EXPECT_TRUE(
1874 notMatches("struct A { void x(A *a) { a->x(this); } };",
1875 binaryOperator(hasOperatorName("->"))));
1876
1877 // Initializer assignments are not represented as operator equals.
1878 EXPECT_TRUE(
1879 notMatches("bool b = true;", binaryOperator(hasOperatorName("="))));
1880
1881 // Array indexing is not represented as operator.
1882 EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));
1883
1884 // Overloaded operators do not match at all.
1885 EXPECT_TRUE(notMatches(
1886 "struct A { bool operator&&(const A &a) const { return false; } };"
1887 "void x() { A a, b; a && b; }",
1888 binaryOperator()));
1889}
1890
1891TEST(MatchUnaryOperator, HasOperatorName) {
1892 StatementMatcher OperatorNot = unaryOperator(hasOperatorName("!"));
1893
1894 EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
1895 EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
1896}
1897
1898TEST(MatchUnaryOperator, HasUnaryOperand) {
1899 StatementMatcher OperatorOnFalse =
1900 unaryOperator(hasUnaryOperand(boolLiteral(equals(false))));
1901
1902 EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
1903 EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));
1904}
1905
1906TEST(Matcher, UnaryOperatorTypes) {
1907 // Integration test that verifies the AST provides all unary operators in
1908 // a way we expect.
1909 EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
1910 EXPECT_TRUE(
1911 matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
1912 EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
1913 EXPECT_TRUE(
1914 matches("bool *p; bool b = *p;", unaryOperator(hasOperatorName("*"))));
1915 EXPECT_TRUE(
1916 matches("int i; int j = +i;", unaryOperator(hasOperatorName("+"))));
1917 EXPECT_TRUE(
1918 matches("int i; int j = -i;", unaryOperator(hasOperatorName("-"))));
1919 EXPECT_TRUE(
1920 matches("int i; int j = ++i;", unaryOperator(hasOperatorName("++"))));
1921 EXPECT_TRUE(
1922 matches("int i; int j = i++;", unaryOperator(hasOperatorName("++"))));
1923 EXPECT_TRUE(
1924 matches("int i; int j = --i;", unaryOperator(hasOperatorName("--"))));
1925 EXPECT_TRUE(
1926 matches("int i; int j = i--;", unaryOperator(hasOperatorName("--"))));
1927
1928 // We don't match conversion operators.
1929 EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));
1930
1931 // Function calls are not represented as operator.
1932 EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));
1933
1934 // Overloaded operators do not match at all.
1935 // FIXME: We probably want to add that.
1936 EXPECT_TRUE(notMatches(
1937 "struct A { bool operator!() const { return false; } };"
1938 "void x() { A a; !a; }", unaryOperator(hasOperatorName("!"))));
1939}
1940
1941TEST(Matcher, ConditionalOperator) {
1942 StatementMatcher Conditional = conditionalOperator(
1943 hasCondition(boolLiteral(equals(true))),
1944 hasTrueExpression(boolLiteral(equals(false))));
1945
1946 EXPECT_TRUE(matches("void x() { true ? false : true; }", Conditional));
1947 EXPECT_TRUE(notMatches("void x() { false ? false : true; }", Conditional));
1948 EXPECT_TRUE(notMatches("void x() { true ? true : false; }", Conditional));
1949
1950 StatementMatcher ConditionalFalse = conditionalOperator(
1951 hasFalseExpression(boolLiteral(equals(false))));
1952
1953 EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
1954 EXPECT_TRUE(
1955 notMatches("void x() { true ? false : true; }", ConditionalFalse));
1956}
1957
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001958TEST(ArraySubscriptMatchers, ArraySubscripts) {
1959 EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 1; }",
1960 arraySubscriptExpr()));
1961 EXPECT_TRUE(notMatches("int i; void f() { i = 1; }",
1962 arraySubscriptExpr()));
1963}
1964
1965TEST(ArraySubscriptMatchers, ArrayIndex) {
1966 EXPECT_TRUE(matches(
1967 "int i[2]; void f() { i[1] = 1; }",
1968 arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
1969 EXPECT_TRUE(matches(
1970 "int i[2]; void f() { 1[i] = 1; }",
1971 arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
1972 EXPECT_TRUE(notMatches(
1973 "int i[2]; void f() { i[1] = 1; }",
1974 arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
1975}
1976
1977TEST(ArraySubscriptMatchers, MatchesArrayBase) {
1978 EXPECT_TRUE(matches(
1979 "int i[2]; void f() { i[1] = 2; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001980 arraySubscriptExpr(hasBase(implicitCastExpr(
1981 hasSourceExpression(declRefExpr()))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00001982}
1983
Manuel Klimek4da21662012-07-06 05:48:52 +00001984TEST(Matcher, HasNameSupportsNamespaces) {
1985 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001986 recordDecl(hasName("a::b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001987 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001988 recordDecl(hasName("::a::b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001989 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001990 recordDecl(hasName("b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001991 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001992 recordDecl(hasName("C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001993 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001994 recordDecl(hasName("c::b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001995 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001996 recordDecl(hasName("a::c::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001997 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00001998 recordDecl(hasName("a::b::A"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00001999 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002000 recordDecl(hasName("::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002001 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002002 recordDecl(hasName("::b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002003 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002004 recordDecl(hasName("z::a::b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002005 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002006 recordDecl(hasName("a+b::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002007 EXPECT_TRUE(notMatches("namespace a { namespace b { class AC; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002008 recordDecl(hasName("C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002009}
2010
2011TEST(Matcher, HasNameSupportsOuterClasses) {
2012 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002013 matches("class A { class B { class C; }; };",
2014 recordDecl(hasName("A::B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002015 EXPECT_TRUE(
2016 matches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002017 recordDecl(hasName("::A::B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002018 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002019 matches("class A { class B { class C; }; };",
2020 recordDecl(hasName("B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002021 EXPECT_TRUE(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002022 matches("class A { class B { class C; }; };",
2023 recordDecl(hasName("C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002024 EXPECT_TRUE(
2025 notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002026 recordDecl(hasName("c::B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002027 EXPECT_TRUE(
2028 notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002029 recordDecl(hasName("A::c::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002030 EXPECT_TRUE(
2031 notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002032 recordDecl(hasName("A::B::A"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002033 EXPECT_TRUE(
2034 notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002035 recordDecl(hasName("::C"))));
2036 EXPECT_TRUE(
2037 notMatches("class A { class B { class C; }; };",
2038 recordDecl(hasName("::B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002039 EXPECT_TRUE(notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002040 recordDecl(hasName("z::A::B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002041 EXPECT_TRUE(
2042 notMatches("class A { class B { class C; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002043 recordDecl(hasName("A+B::C"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002044}
2045
2046TEST(Matcher, IsDefinition) {
2047 DeclarationMatcher DefinitionOfClassA =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002048 recordDecl(hasName("A"), isDefinition());
Manuel Klimek4da21662012-07-06 05:48:52 +00002049 EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
2050 EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
2051
2052 DeclarationMatcher DefinitionOfVariableA =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002053 varDecl(hasName("a"), isDefinition());
Manuel Klimek4da21662012-07-06 05:48:52 +00002054 EXPECT_TRUE(matches("int a;", DefinitionOfVariableA));
2055 EXPECT_TRUE(notMatches("extern int a;", DefinitionOfVariableA));
2056
2057 DeclarationMatcher DefinitionOfMethodA =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002058 methodDecl(hasName("a"), isDefinition());
Manuel Klimek4da21662012-07-06 05:48:52 +00002059 EXPECT_TRUE(matches("class A { void a() {} };", DefinitionOfMethodA));
2060 EXPECT_TRUE(notMatches("class A { void a(); };", DefinitionOfMethodA));
2061}
2062
2063TEST(Matcher, OfClass) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002064 StatementMatcher Constructor = constructExpr(hasDeclaration(methodDecl(
Manuel Klimek4da21662012-07-06 05:48:52 +00002065 ofClass(hasName("X")))));
2066
2067 EXPECT_TRUE(
2068 matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
2069 EXPECT_TRUE(
2070 matches("class X { public: X(); }; void x(int) { X x = X(); }",
2071 Constructor));
2072 EXPECT_TRUE(
2073 notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
2074 Constructor));
2075}
2076
2077TEST(Matcher, VisitsTemplateInstantiations) {
2078 EXPECT_TRUE(matches(
2079 "class A { public: void x(); };"
2080 "template <typename T> class B { public: void y() { T t; t.x(); } };"
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002081 "void f() { B<A> b; b.y(); }",
2082 callExpr(callee(methodDecl(hasName("x"))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002083
2084 EXPECT_TRUE(matches(
2085 "class A { public: void x(); };"
2086 "class C {"
2087 " public:"
2088 " template <typename T> class B { public: void y() { T t; t.x(); } };"
2089 "};"
2090 "void f() {"
2091 " C::B<A> b; b.y();"
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002092 "}",
2093 recordDecl(hasName("C"),
2094 hasDescendant(callExpr(callee(methodDecl(hasName("x"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002095}
2096
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002097TEST(Matcher, HandlesNullQualTypes) {
2098 // FIXME: Add a Type matcher so we can replace uses of this
2099 // variable with Type(True())
2100 const TypeMatcher AnyType = anything();
2101
2102 // We don't really care whether this matcher succeeds; we're testing that
2103 // it completes without crashing.
2104 EXPECT_TRUE(matches(
2105 "struct A { };"
2106 "template <typename T>"
2107 "void f(T t) {"
2108 " T local_t(t /* this becomes a null QualType in the AST */);"
2109 "}"
2110 "void g() {"
2111 " f(0);"
2112 "}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002113 expr(hasType(TypeMatcher(
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002114 anyOf(
2115 TypeMatcher(hasDeclaration(anything())),
2116 pointsTo(AnyType),
2117 references(AnyType)
2118 // Other QualType matchers should go here.
2119 ))))));
2120}
2121
Manuel Klimek4da21662012-07-06 05:48:52 +00002122// For testing AST_MATCHER_P().
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002123AST_MATCHER_P(Decl, just, internal::Matcher<Decl>, AMatcher) {
Manuel Klimek4da21662012-07-06 05:48:52 +00002124 // Make sure all special variables are used: node, match_finder,
2125 // bound_nodes_builder, and the parameter named 'AMatcher'.
2126 return AMatcher.matches(Node, Finder, Builder);
2127}
2128
2129TEST(AstMatcherPMacro, Works) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002130 DeclarationMatcher HasClassB = just(has(recordDecl(hasName("B")).bind("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002131
2132 EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002133 HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002134
2135 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002136 HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002137
2138 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002139 HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002140}
2141
2142AST_POLYMORPHIC_MATCHER_P(
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002143 polymorphicHas, internal::Matcher<Decl>, AMatcher) {
2144 TOOLING_COMPILE_ASSERT((llvm::is_same<NodeType, Decl>::value) ||
2145 (llvm::is_same<NodeType, Stmt>::value),
Manuel Klimek4da21662012-07-06 05:48:52 +00002146 assert_node_type_is_accessible);
Manuel Klimek4da21662012-07-06 05:48:52 +00002147 return Finder->matchesChildOf(
Manuel Klimeka78d0d62012-09-05 12:12:07 +00002148 Node, AMatcher, Builder,
Manuel Klimek4da21662012-07-06 05:48:52 +00002149 ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
2150 ASTMatchFinder::BK_First);
2151}
2152
2153TEST(AstPolymorphicMatcherPMacro, Works) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002154 DeclarationMatcher HasClassB =
2155 polymorphicHas(recordDecl(hasName("B")).bind("b"));
Manuel Klimek4da21662012-07-06 05:48:52 +00002156
2157 EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002158 HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002159
2160 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class B {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002161 HasClassB, new VerifyIdIsBoundTo<Decl>("a")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002162
2163 EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
Daniel Jaspera7564432012-09-13 13:11:25 +00002164 HasClassB, new VerifyIdIsBoundTo<Decl>("b")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002165
2166 StatementMatcher StatementHasClassB =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002167 polymorphicHas(recordDecl(hasName("B")));
Manuel Klimek4da21662012-07-06 05:48:52 +00002168
2169 EXPECT_TRUE(matches("void x() { class B {}; }", StatementHasClassB));
2170}
2171
2172TEST(For, FindsForLoops) {
2173 EXPECT_TRUE(matches("void f() { for(;;); }", forStmt()));
2174 EXPECT_TRUE(matches("void f() { if(true) for(;;); }", forStmt()));
Daniel Jasper1a00fee2012-10-01 15:05:34 +00002175 EXPECT_TRUE(notMatches("int as[] = { 1, 2, 3 };"
2176 "void f() { for (auto &a : as); }",
Daniel Jasper31f7c082012-10-01 13:40:41 +00002177 forStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002178}
2179
Daniel Jasper6a124492012-07-12 08:50:38 +00002180TEST(For, ForLoopInternals) {
2181 EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
2182 forStmt(hasCondition(anything()))));
2183 EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
2184 forStmt(hasLoopInit(anything()))));
2185}
2186
2187TEST(For, NegativeForLoopInternals) {
2188 EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002189 forStmt(hasCondition(expr()))));
Daniel Jasper6a124492012-07-12 08:50:38 +00002190 EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
2191 forStmt(hasLoopInit(anything()))));
2192}
2193
Manuel Klimek4da21662012-07-06 05:48:52 +00002194TEST(For, ReportsNoFalsePositives) {
2195 EXPECT_TRUE(notMatches("void f() { ; }", forStmt()));
2196 EXPECT_TRUE(notMatches("void f() { if(true); }", forStmt()));
2197}
2198
2199TEST(CompoundStatement, HandlesSimpleCases) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002200 EXPECT_TRUE(notMatches("void f();", compoundStmt()));
2201 EXPECT_TRUE(matches("void f() {}", compoundStmt()));
2202 EXPECT_TRUE(matches("void f() {{}}", compoundStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002203}
2204
2205TEST(CompoundStatement, DoesNotMatchEmptyStruct) {
2206 // It's not a compound statement just because there's "{}" in the source
2207 // text. This is an AST search, not grep.
2208 EXPECT_TRUE(notMatches("namespace n { struct S {}; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002209 compoundStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002210 EXPECT_TRUE(matches("namespace n { struct S { void f() {{}} }; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002211 compoundStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002212}
2213
Daniel Jasper6a124492012-07-12 08:50:38 +00002214TEST(HasBody, FindsBodyOfForWhileDoLoops) {
Manuel Klimek4da21662012-07-06 05:48:52 +00002215 EXPECT_TRUE(matches("void f() { for(;;) {} }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002216 forStmt(hasBody(compoundStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002217 EXPECT_TRUE(notMatches("void f() { for(;;); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002218 forStmt(hasBody(compoundStmt()))));
Daniel Jasper6a124492012-07-12 08:50:38 +00002219 EXPECT_TRUE(matches("void f() { while(true) {} }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002220 whileStmt(hasBody(compoundStmt()))));
Daniel Jasper6a124492012-07-12 08:50:38 +00002221 EXPECT_TRUE(matches("void f() { do {} while(true); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002222 doStmt(hasBody(compoundStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002223}
2224
2225TEST(HasAnySubstatement, MatchesForTopLevelCompoundStatement) {
2226 // The simplest case: every compound statement is in a function
2227 // definition, and the function body itself must be a compound
2228 // statement.
2229 EXPECT_TRUE(matches("void f() { for (;;); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002230 compoundStmt(hasAnySubstatement(forStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002231}
2232
2233TEST(HasAnySubstatement, IsNotRecursive) {
2234 // It's really "has any immediate substatement".
2235 EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002236 compoundStmt(hasAnySubstatement(forStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002237}
2238
2239TEST(HasAnySubstatement, MatchesInNestedCompoundStatements) {
2240 EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002241 compoundStmt(hasAnySubstatement(forStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002242}
2243
2244TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
2245 EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002246 compoundStmt(hasAnySubstatement(forStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002247}
2248
2249TEST(StatementCountIs, FindsNoStatementsInAnEmptyCompoundStatement) {
2250 EXPECT_TRUE(matches("void f() { }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002251 compoundStmt(statementCountIs(0))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002252 EXPECT_TRUE(notMatches("void f() {}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002253 compoundStmt(statementCountIs(1))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002254}
2255
2256TEST(StatementCountIs, AppearsToMatchOnlyOneCount) {
2257 EXPECT_TRUE(matches("void f() { 1; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002258 compoundStmt(statementCountIs(1))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002259 EXPECT_TRUE(notMatches("void f() { 1; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002260 compoundStmt(statementCountIs(0))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002261 EXPECT_TRUE(notMatches("void f() { 1; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002262 compoundStmt(statementCountIs(2))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002263}
2264
2265TEST(StatementCountIs, WorksWithMultipleStatements) {
2266 EXPECT_TRUE(matches("void f() { 1; 2; 3; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002267 compoundStmt(statementCountIs(3))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002268}
2269
2270TEST(StatementCountIs, WorksWithNestedCompoundStatements) {
2271 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002272 compoundStmt(statementCountIs(1))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002273 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002274 compoundStmt(statementCountIs(2))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002275 EXPECT_TRUE(notMatches("void f() { { 1; } { 1; 2; 3; 4; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002276 compoundStmt(statementCountIs(3))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002277 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002278 compoundStmt(statementCountIs(4))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002279}
2280
2281TEST(Member, WorksInSimplestCase) {
2282 EXPECT_TRUE(matches("struct { int first; } s; int i(s.first);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002283 memberExpr(member(hasName("first")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002284}
2285
2286TEST(Member, DoesNotMatchTheBaseExpression) {
2287 // Don't pick out the wrong part of the member expression, this should
2288 // be checking the member (name) only.
2289 EXPECT_TRUE(notMatches("struct { int i; } first; int i(first.i);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002290 memberExpr(member(hasName("first")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002291}
2292
2293TEST(Member, MatchesInMemberFunctionCall) {
2294 EXPECT_TRUE(matches("void f() {"
2295 " struct { void first() {}; } s;"
2296 " s.first();"
2297 "};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002298 memberExpr(member(hasName("first")))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002299}
2300
Daniel Jasperc711af22012-10-23 15:46:39 +00002301TEST(Member, MatchesMember) {
2302 EXPECT_TRUE(matches(
2303 "struct A { int i; }; void f() { A a; a.i = 2; }",
2304 memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
2305 EXPECT_TRUE(notMatches(
2306 "struct A { float f; }; void f() { A a; a.f = 2.0f; }",
2307 memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
2308}
2309
Daniel Jasperf3197e92013-02-25 12:02:08 +00002310TEST(Member, UnderstandsAccess) {
2311 EXPECT_TRUE(matches(
2312 "struct A { int i; };", fieldDecl(isPublic(), hasName("i"))));
2313 EXPECT_TRUE(notMatches(
2314 "struct A { int i; };", fieldDecl(isProtected(), hasName("i"))));
2315 EXPECT_TRUE(notMatches(
2316 "struct A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
2317
2318 EXPECT_TRUE(notMatches(
2319 "class A { int i; };", fieldDecl(isPublic(), hasName("i"))));
2320 EXPECT_TRUE(notMatches(
2321 "class A { int i; };", fieldDecl(isProtected(), hasName("i"))));
2322 EXPECT_TRUE(matches(
2323 "class A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
2324
2325 EXPECT_TRUE(notMatches(
2326 "class A { protected: int i; };", fieldDecl(isPublic(), hasName("i"))));
2327 EXPECT_TRUE(matches("class A { protected: int i; };",
2328 fieldDecl(isProtected(), hasName("i"))));
2329 EXPECT_TRUE(notMatches(
2330 "class A { protected: int i; };", fieldDecl(isPrivate(), hasName("i"))));
2331
2332 // Non-member decls have the AccessSpecifier AS_none and thus aren't matched.
2333 EXPECT_TRUE(notMatches("int i;", varDecl(isPublic(), hasName("i"))));
2334 EXPECT_TRUE(notMatches("int i;", varDecl(isProtected(), hasName("i"))));
2335 EXPECT_TRUE(notMatches("int i;", varDecl(isPrivate(), hasName("i"))));
2336}
2337
Dmitri Gribenko671a0452012-08-18 00:29:27 +00002338TEST(Member, MatchesMemberAllocationFunction) {
Daniel Jasper31f7c082012-10-01 13:40:41 +00002339 // Fails in C++11 mode
2340 EXPECT_TRUE(matchesConditionally(
2341 "namespace std { typedef typeof(sizeof(int)) size_t; }"
2342 "class X { void *operator new(std::size_t); };",
2343 methodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
Dmitri Gribenko671a0452012-08-18 00:29:27 +00002344
2345 EXPECT_TRUE(matches("class X { void operator delete(void*); };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002346 methodDecl(ofClass(hasName("X")))));
Dmitri Gribenko671a0452012-08-18 00:29:27 +00002347
Daniel Jasper31f7c082012-10-01 13:40:41 +00002348 // Fails in C++11 mode
2349 EXPECT_TRUE(matchesConditionally(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002350 "namespace std { typedef typeof(sizeof(int)) size_t; }"
2351 "class X { void operator delete[](void*, std::size_t); };",
Daniel Jasper31f7c082012-10-01 13:40:41 +00002352 methodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
Dmitri Gribenko671a0452012-08-18 00:29:27 +00002353}
2354
Manuel Klimek4da21662012-07-06 05:48:52 +00002355TEST(HasObjectExpression, DoesNotMatchMember) {
2356 EXPECT_TRUE(notMatches(
2357 "class X {}; struct Z { X m; }; void f(Z z) { z.m; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002358 memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002359}
2360
2361TEST(HasObjectExpression, MatchesBaseOfVariable) {
2362 EXPECT_TRUE(matches(
2363 "struct X { int m; }; void f(X x) { x.m; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002364 memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002365 EXPECT_TRUE(matches(
2366 "struct X { int m; }; void f(X* x) { x->m; }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002367 memberExpr(hasObjectExpression(
2368 hasType(pointsTo(recordDecl(hasName("X"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002369}
2370
2371TEST(HasObjectExpression,
2372 MatchesObjectExpressionOfImplicitlyFormedMemberExpression) {
2373 EXPECT_TRUE(matches(
2374 "class X {}; struct S { X m; void f() { this->m; } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002375 memberExpr(hasObjectExpression(
2376 hasType(pointsTo(recordDecl(hasName("S"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002377 EXPECT_TRUE(matches(
2378 "class X {}; struct S { X m; void f() { m; } };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002379 memberExpr(hasObjectExpression(
2380 hasType(pointsTo(recordDecl(hasName("S"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002381}
2382
2383TEST(Field, DoesNotMatchNonFieldMembers) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002384 EXPECT_TRUE(notMatches("class X { void m(); };", fieldDecl(hasName("m"))));
2385 EXPECT_TRUE(notMatches("class X { class m {}; };", fieldDecl(hasName("m"))));
2386 EXPECT_TRUE(notMatches("class X { enum { m }; };", fieldDecl(hasName("m"))));
2387 EXPECT_TRUE(notMatches("class X { enum m {}; };", fieldDecl(hasName("m"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002388}
2389
2390TEST(Field, MatchesField) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002391 EXPECT_TRUE(matches("class X { int m; };", fieldDecl(hasName("m"))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002392}
2393
2394TEST(IsConstQualified, MatchesConstInt) {
2395 EXPECT_TRUE(matches("const int i = 42;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002396 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002397}
2398
2399TEST(IsConstQualified, MatchesConstPointer) {
2400 EXPECT_TRUE(matches("int i = 42; int* const p(&i);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002401 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002402}
2403
2404TEST(IsConstQualified, MatchesThroughTypedef) {
2405 EXPECT_TRUE(matches("typedef const int const_int; const_int i = 42;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002406 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002407 EXPECT_TRUE(matches("typedef int* int_ptr; const int_ptr p(0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002408 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002409}
2410
2411TEST(IsConstQualified, DoesNotMatchInappropriately) {
2412 EXPECT_TRUE(notMatches("typedef int nonconst_int; nonconst_int i = 42;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002413 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002414 EXPECT_TRUE(notMatches("int const* p;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002415 varDecl(hasType(isConstQualified()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002416}
2417
Sam Panzer089e5b32012-08-16 16:58:10 +00002418TEST(CastExpression, MatchesExplicitCasts) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002419 EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
2420 EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
2421 EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
2422 EXPECT_TRUE(matches("char c = char(0);", castExpr()));
Sam Panzer089e5b32012-08-16 16:58:10 +00002423}
2424TEST(CastExpression, MatchesImplicitCasts) {
2425 // This test creates an implicit cast from int to char.
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002426 EXPECT_TRUE(matches("char c = 0;", castExpr()));
Sam Panzer089e5b32012-08-16 16:58:10 +00002427 // This test creates an implicit cast from lvalue to rvalue.
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002428 EXPECT_TRUE(matches("char c = 0, d = c;", castExpr()));
Sam Panzer089e5b32012-08-16 16:58:10 +00002429}
2430
2431TEST(CastExpression, DoesNotMatchNonCasts) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002432 EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
2433 EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
2434 EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
2435 EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
Sam Panzer089e5b32012-08-16 16:58:10 +00002436}
2437
Manuel Klimek4da21662012-07-06 05:48:52 +00002438TEST(ReinterpretCast, MatchesSimpleCase) {
2439 EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002440 reinterpretCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002441}
2442
2443TEST(ReinterpretCast, DoesNotMatchOtherCasts) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002444 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", reinterpretCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002445 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002446 reinterpretCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002447 EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002448 reinterpretCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002449 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
2450 "B b;"
2451 "D* p = dynamic_cast<D*>(&b);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002452 reinterpretCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002453}
2454
2455TEST(FunctionalCast, MatchesSimpleCase) {
2456 std::string foo_class = "class Foo { public: Foo(char*); };";
2457 EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002458 functionalCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002459}
2460
2461TEST(FunctionalCast, DoesNotMatchOtherCasts) {
2462 std::string FooClass = "class Foo { public: Foo(char*); };";
2463 EXPECT_TRUE(
2464 notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002465 functionalCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002466 EXPECT_TRUE(
2467 notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002468 functionalCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002469}
2470
2471TEST(DynamicCast, MatchesSimpleCase) {
2472 EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
2473 "B b;"
2474 "D* p = dynamic_cast<D*>(&b);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002475 dynamicCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002476}
2477
2478TEST(StaticCast, MatchesSimpleCase) {
2479 EXPECT_TRUE(matches("void* p(static_cast<void*>(&p));",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002480 staticCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002481}
2482
2483TEST(StaticCast, DoesNotMatchOtherCasts) {
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002484 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", staticCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002485 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002486 staticCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002487 EXPECT_TRUE(notMatches("void* p = reinterpret_cast<char*>(&p);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002488 staticCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002489 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
2490 "B b;"
2491 "D* p = dynamic_cast<D*>(&b);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002492 staticCastExpr()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002493}
2494
Daniel Jaspere6d2a962012-09-18 13:36:17 +00002495TEST(CStyleCast, MatchesSimpleCase) {
2496 EXPECT_TRUE(matches("int i = (int) 2.2f;", cStyleCastExpr()));
2497}
2498
2499TEST(CStyleCast, DoesNotMatchOtherCasts) {
2500 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
2501 "char q, *r = const_cast<char*>(&q);"
2502 "void* s = reinterpret_cast<char*>(&s);"
2503 "struct B { virtual ~B() {} }; struct D : B {};"
2504 "B b;"
2505 "D* t = dynamic_cast<D*>(&b);",
2506 cStyleCastExpr()));
2507}
2508
Manuel Klimek4da21662012-07-06 05:48:52 +00002509TEST(HasDestinationType, MatchesSimpleCase) {
2510 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002511 staticCastExpr(hasDestinationType(
2512 pointsTo(TypeMatcher(anything()))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002513}
2514
Sam Panzer089e5b32012-08-16 16:58:10 +00002515TEST(HasImplicitDestinationType, MatchesSimpleCase) {
2516 // This test creates an implicit const cast.
2517 EXPECT_TRUE(matches("int x; const int i = x;",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002518 implicitCastExpr(
2519 hasImplicitDestinationType(isInteger()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002520 // This test creates an implicit array-to-pointer cast.
2521 EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002522 implicitCastExpr(hasImplicitDestinationType(
2523 pointsTo(TypeMatcher(anything()))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002524}
2525
2526TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
2527 // This test creates an implicit cast from int to char.
2528 EXPECT_TRUE(notMatches("char c = 0;",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002529 implicitCastExpr(hasImplicitDestinationType(
2530 unless(anything())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002531 // This test creates an implicit array-to-pointer cast.
2532 EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002533 implicitCastExpr(hasImplicitDestinationType(
2534 unless(anything())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002535}
2536
2537TEST(ImplicitCast, MatchesSimpleCase) {
2538 // This test creates an implicit const cast.
2539 EXPECT_TRUE(matches("int x = 0; const int y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002540 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002541 // This test creates an implicit cast from int to char.
2542 EXPECT_TRUE(matches("char c = 0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002543 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002544 // This test creates an implicit array-to-pointer cast.
2545 EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002546 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002547}
2548
2549TEST(ImplicitCast, DoesNotMatchIncorrectly) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002550 // This test verifies that implicitCastExpr() matches exactly when implicit casts
Sam Panzer089e5b32012-08-16 16:58:10 +00002551 // are present, and that it ignores explicit and paren casts.
2552
2553 // These two test cases have no casts.
2554 EXPECT_TRUE(notMatches("int x = 0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002555 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002556 EXPECT_TRUE(notMatches("int x = 0, &y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002557 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002558
2559 EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002560 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002561 EXPECT_TRUE(notMatches("const int *p; int *q = const_cast<int *>(p);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002562 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002563
2564 EXPECT_TRUE(notMatches("int x = (0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002565 varDecl(hasInitializer(implicitCastExpr()))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002566}
2567
2568TEST(IgnoringImpCasts, MatchesImpCasts) {
2569 // This test checks that ignoringImpCasts matches when implicit casts are
2570 // present and its inner matcher alone does not match.
2571 // Note that this test creates an implicit const cast.
2572 EXPECT_TRUE(matches("int x = 0; const int y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002573 varDecl(hasInitializer(ignoringImpCasts(
2574 declRefExpr(to(varDecl(hasName("x")))))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002575 // This test creates an implict cast from int to char.
2576 EXPECT_TRUE(matches("char x = 0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002577 varDecl(hasInitializer(ignoringImpCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002578 integerLiteral(equals(0)))))));
2579}
2580
2581TEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
2582 // These tests verify that ignoringImpCasts does not match if the inner
2583 // matcher does not match.
2584 // Note that the first test creates an implicit const cast.
2585 EXPECT_TRUE(notMatches("int x; const int y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002586 varDecl(hasInitializer(ignoringImpCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002587 unless(anything()))))));
2588 EXPECT_TRUE(notMatches("int x; int y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002589 varDecl(hasInitializer(ignoringImpCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002590 unless(anything()))))));
2591
2592 // These tests verify that ignoringImplictCasts does not look through explicit
2593 // casts or parentheses.
2594 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002595 varDecl(hasInitializer(ignoringImpCasts(
2596 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002597 EXPECT_TRUE(notMatches("int i = (0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002598 varDecl(hasInitializer(ignoringImpCasts(
2599 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002600 EXPECT_TRUE(notMatches("float i = (float)0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002601 varDecl(hasInitializer(ignoringImpCasts(
2602 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002603 EXPECT_TRUE(notMatches("float i = float(0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002604 varDecl(hasInitializer(ignoringImpCasts(
2605 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002606}
2607
2608TEST(IgnoringImpCasts, MatchesWithoutImpCasts) {
2609 // This test verifies that expressions that do not have implicit casts
2610 // still match the inner matcher.
2611 EXPECT_TRUE(matches("int x = 0; int &y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002612 varDecl(hasInitializer(ignoringImpCasts(
2613 declRefExpr(to(varDecl(hasName("x")))))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002614}
2615
2616TEST(IgnoringParenCasts, MatchesParenCasts) {
2617 // This test checks that ignoringParenCasts matches when parentheses and/or
2618 // casts are present and its inner matcher alone does not match.
2619 EXPECT_TRUE(matches("int x = (0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002620 varDecl(hasInitializer(ignoringParenCasts(
2621 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002622 EXPECT_TRUE(matches("int x = (((((0)))));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002623 varDecl(hasInitializer(ignoringParenCasts(
2624 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002625
2626 // This test creates an implict cast from int to char in addition to the
2627 // parentheses.
2628 EXPECT_TRUE(matches("char x = (0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002629 varDecl(hasInitializer(ignoringParenCasts(
2630 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002631
2632 EXPECT_TRUE(matches("char x = (char)0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002633 varDecl(hasInitializer(ignoringParenCasts(
2634 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002635 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002636 varDecl(hasInitializer(ignoringParenCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002637 integerLiteral(equals(0)))))));
2638}
2639
2640TEST(IgnoringParenCasts, MatchesWithoutParenCasts) {
2641 // This test verifies that expressions that do not have any casts still match.
2642 EXPECT_TRUE(matches("int x = 0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002643 varDecl(hasInitializer(ignoringParenCasts(
2644 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002645}
2646
2647TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) {
2648 // These tests verify that ignoringImpCasts does not match if the inner
2649 // matcher does not match.
2650 EXPECT_TRUE(notMatches("int x = ((0));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002651 varDecl(hasInitializer(ignoringParenCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002652 unless(anything()))))));
2653
2654 // This test creates an implicit cast from int to char in addition to the
2655 // parentheses.
2656 EXPECT_TRUE(notMatches("char x = ((0));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002657 varDecl(hasInitializer(ignoringParenCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002658 unless(anything()))))));
2659
2660 EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002661 varDecl(hasInitializer(ignoringParenCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002662 unless(anything()))))));
2663}
2664
2665TEST(IgnoringParenAndImpCasts, MatchesParenImpCasts) {
2666 // This test checks that ignoringParenAndImpCasts matches when
2667 // parentheses and/or implicit casts are present and its inner matcher alone
2668 // does not match.
2669 // Note that this test creates an implicit const cast.
2670 EXPECT_TRUE(matches("int x = 0; const int y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002671 varDecl(hasInitializer(ignoringParenImpCasts(
2672 declRefExpr(to(varDecl(hasName("x")))))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002673 // This test creates an implicit cast from int to char.
2674 EXPECT_TRUE(matches("const char x = (0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002675 varDecl(hasInitializer(ignoringParenImpCasts(
2676 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002677}
2678
2679TEST(IgnoringParenAndImpCasts, MatchesWithoutParenImpCasts) {
2680 // This test verifies that expressions that do not have parentheses or
2681 // implicit casts still match.
2682 EXPECT_TRUE(matches("int x = 0; int &y = x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002683 varDecl(hasInitializer(ignoringParenImpCasts(
2684 declRefExpr(to(varDecl(hasName("x")))))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002685 EXPECT_TRUE(matches("int x = 0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002686 varDecl(hasInitializer(ignoringParenImpCasts(
2687 integerLiteral(equals(0)))))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002688}
2689
2690TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) {
2691 // These tests verify that ignoringParenImpCasts does not match if
2692 // the inner matcher does not match.
2693 // This test creates an implicit cast.
2694 EXPECT_TRUE(notMatches("char c = ((3));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002695 varDecl(hasInitializer(ignoringParenImpCasts(
Sam Panzer089e5b32012-08-16 16:58:10 +00002696 unless(anything()))))));
2697 // These tests verify that ignoringParenAndImplictCasts does not look
2698 // through explicit casts.
2699 EXPECT_TRUE(notMatches("float y = (float(0));",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002700 varDecl(hasInitializer(ignoringParenImpCasts(
2701 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002702 EXPECT_TRUE(notMatches("float y = (float)0;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002703 varDecl(hasInitializer(ignoringParenImpCasts(
2704 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002705 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002706 varDecl(hasInitializer(ignoringParenImpCasts(
2707 integerLiteral())))));
Sam Panzer089e5b32012-08-16 16:58:10 +00002708}
2709
Manuel Klimek715c9562012-07-25 10:02:02 +00002710TEST(HasSourceExpression, MatchesImplicitCasts) {
Manuel Klimek4da21662012-07-06 05:48:52 +00002711 EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
2712 "void r() {string a_string; URL url = a_string; }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002713 implicitCastExpr(
2714 hasSourceExpression(constructExpr()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002715}
2716
Manuel Klimek715c9562012-07-25 10:02:02 +00002717TEST(HasSourceExpression, MatchesExplicitCasts) {
2718 EXPECT_TRUE(matches("float x = static_cast<float>(42);",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002719 explicitCastExpr(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002720 hasSourceExpression(hasDescendant(
Daniel Jasper3680b4f2012-09-18 13:09:13 +00002721 expr(integerLiteral()))))));
Manuel Klimek715c9562012-07-25 10:02:02 +00002722}
2723
Manuel Klimek4da21662012-07-06 05:48:52 +00002724TEST(Statement, DoesNotMatchDeclarations) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002725 EXPECT_TRUE(notMatches("class X {};", stmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002726}
2727
2728TEST(Statement, MatchesCompoundStatments) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002729 EXPECT_TRUE(matches("void x() {}", stmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002730}
2731
2732TEST(DeclarationStatement, DoesNotMatchCompoundStatements) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002733 EXPECT_TRUE(notMatches("void x() {}", declStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002734}
2735
2736TEST(DeclarationStatement, MatchesVariableDeclarationStatements) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002737 EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
Manuel Klimek4da21662012-07-06 05:48:52 +00002738}
2739
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002740TEST(InitListExpression, MatchesInitListExpression) {
2741 EXPECT_TRUE(matches("int a[] = { 1, 2 };",
2742 initListExpr(hasType(asString("int [2]")))));
2743 EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002744 initListExpr(hasType(recordDecl(hasName("B"))))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002745}
2746
2747TEST(UsingDeclaration, MatchesUsingDeclarations) {
2748 EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
2749 usingDecl()));
2750}
2751
2752TEST(UsingDeclaration, MatchesShadowUsingDelcarations) {
2753 EXPECT_TRUE(matches("namespace f { int a; } using f::a;",
2754 usingDecl(hasAnyUsingShadowDecl(hasName("a")))));
2755}
2756
2757TEST(UsingDeclaration, MatchesSpecificTarget) {
2758 EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
2759 usingDecl(hasAnyUsingShadowDecl(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002760 hasTargetDecl(functionDecl())))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002761 EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
2762 usingDecl(hasAnyUsingShadowDecl(
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002763 hasTargetDecl(functionDecl())))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002764}
2765
2766TEST(UsingDeclaration, ThroughUsingDeclaration) {
2767 EXPECT_TRUE(matches(
2768 "namespace a { void f(); } using a::f; void g() { f(); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002769 declRefExpr(throughUsingDecl(anything()))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002770 EXPECT_TRUE(notMatches(
2771 "namespace a { void f(); } using a::f; void g() { a::f(); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002772 declRefExpr(throughUsingDecl(anything()))));
Daniel Jaspere0e6b9e2012-07-10 20:20:19 +00002773}
2774
Sam Panzer425f41b2012-08-16 17:20:59 +00002775TEST(SingleDecl, IsSingleDecl) {
2776 StatementMatcher SingleDeclStmt =
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002777 declStmt(hasSingleDecl(varDecl(hasInitializer(anything()))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002778 EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
2779 EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
2780 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
2781 SingleDeclStmt));
2782}
2783
2784TEST(DeclStmt, ContainsDeclaration) {
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002785 DeclarationMatcher MatchesInit = varDecl(hasInitializer(anything()));
Sam Panzer425f41b2012-08-16 17:20:59 +00002786
2787 EXPECT_TRUE(matches("void f() {int a = 4;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002788 declStmt(containsDeclaration(0, MatchesInit))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002789 EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002790 declStmt(containsDeclaration(0, MatchesInit),
2791 containsDeclaration(1, MatchesInit))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002792 unsigned WrongIndex = 42;
2793 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002794 declStmt(containsDeclaration(WrongIndex,
Sam Panzer425f41b2012-08-16 17:20:59 +00002795 MatchesInit))));
2796}
2797
2798TEST(DeclCount, DeclCountIsCorrect) {
2799 EXPECT_TRUE(matches("void f() {int i,j;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002800 declStmt(declCountIs(2))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002801 EXPECT_TRUE(notMatches("void f() {int i,j; int k;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002802 declStmt(declCountIs(3))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002803 EXPECT_TRUE(notMatches("void f() {int i,j, k, l;}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002804 declStmt(declCountIs(3))));
Sam Panzer425f41b2012-08-16 17:20:59 +00002805}
2806
Manuel Klimek4da21662012-07-06 05:48:52 +00002807TEST(While, MatchesWhileLoops) {
2808 EXPECT_TRUE(notMatches("void x() {}", whileStmt()));
2809 EXPECT_TRUE(matches("void x() { while(true); }", whileStmt()));
2810 EXPECT_TRUE(notMatches("void x() { do {} while(true); }", whileStmt()));
2811}
2812
2813TEST(Do, MatchesDoLoops) {
2814 EXPECT_TRUE(matches("void x() { do {} while(true); }", doStmt()));
2815 EXPECT_TRUE(matches("void x() { do ; while(false); }", doStmt()));
2816}
2817
2818TEST(Do, DoesNotMatchWhileLoops) {
2819 EXPECT_TRUE(notMatches("void x() { while(true) {} }", doStmt()));
2820}
2821
2822TEST(SwitchCase, MatchesCase) {
2823 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchCase()));
2824 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchCase()));
2825 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchCase()));
2826 EXPECT_TRUE(notMatches("void x() { switch(42) {} }", switchCase()));
2827}
2828
Daniel Jasperb54b7642012-09-20 14:12:57 +00002829TEST(SwitchCase, MatchesSwitch) {
2830 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchStmt()));
2831 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchStmt()));
2832 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchStmt()));
2833 EXPECT_TRUE(notMatches("void x() {}", switchStmt()));
2834}
2835
2836TEST(ExceptionHandling, SimpleCases) {
2837 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", catchStmt()));
2838 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", tryStmt()));
2839 EXPECT_TRUE(notMatches("void foo() try { } catch(int X) { }", throwExpr()));
2840 EXPECT_TRUE(matches("void foo() try { throw; } catch(int X) { }",
2841 throwExpr()));
2842 EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }",
2843 throwExpr()));
2844}
2845
Manuel Klimek4da21662012-07-06 05:48:52 +00002846TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
2847 EXPECT_TRUE(notMatches(
2848 "void x() { if(true) {} }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002849 ifStmt(hasConditionVariableStatement(declStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002850 EXPECT_TRUE(notMatches(
2851 "void x() { int x; if((x = 42)) {} }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002852 ifStmt(hasConditionVariableStatement(declStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002853}
2854
2855TEST(HasConditionVariableStatement, MatchesConditionVariables) {
2856 EXPECT_TRUE(matches(
2857 "void x() { if(int* a = 0) {} }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002858 ifStmt(hasConditionVariableStatement(declStmt()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002859}
2860
2861TEST(ForEach, BindsOneNode) {
2862 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002863 recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002864 new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002865}
2866
2867TEST(ForEach, BindsMultipleNodes) {
2868 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002869 recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002870 new VerifyIdIsBoundTo<FieldDecl>("f", 3)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002871}
2872
2873TEST(ForEach, BindsRecursiveCombinations) {
2874 EXPECT_TRUE(matchAndVerifyResultTrue(
2875 "class C { class D { int x; int y; }; class E { int y; int z; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002876 recordDecl(hasName("C"),
2877 forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002878 new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002879}
2880
2881TEST(ForEachDescendant, BindsOneNode) {
2882 EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002883 recordDecl(hasName("C"),
2884 forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002885 new VerifyIdIsBoundTo<FieldDecl>("x", 1)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002886}
2887
Daniel Jasper5f684e92012-11-16 18:39:22 +00002888TEST(ForEachDescendant, NestedForEachDescendant) {
2889 DeclarationMatcher m = recordDecl(
2890 isDefinition(), decl().bind("x"), hasName("C"));
2891 EXPECT_TRUE(matchAndVerifyResultTrue(
2892 "class A { class B { class C {}; }; };",
2893 recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
2894 new VerifyIdIsBoundTo<Decl>("x", "C")));
2895
2896 // FIXME: This is not really a useful matcher, but the result is still
2897 // surprising (currently binds "A").
2898 //EXPECT_TRUE(matchAndVerifyResultTrue(
2899 // "class A { class B { class C {}; }; };",
2900 // recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
2901 // new VerifyIdIsBoundTo<Decl>("x", "C")));
2902}
2903
Manuel Klimek4da21662012-07-06 05:48:52 +00002904TEST(ForEachDescendant, BindsMultipleNodes) {
2905 EXPECT_TRUE(matchAndVerifyResultTrue(
2906 "class C { class D { int x; int y; }; "
2907 " class E { class F { int y; int z; }; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002908 recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002909 new VerifyIdIsBoundTo<FieldDecl>("f", 4)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002910}
2911
2912TEST(ForEachDescendant, BindsRecursiveCombinations) {
2913 EXPECT_TRUE(matchAndVerifyResultTrue(
2914 "class C { class D { "
2915 " class E { class F { class G { int y; int z; }; }; }; }; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002916 recordDecl(hasName("C"), forEachDescendant(recordDecl(
2917 forEachDescendant(fieldDecl().bind("f"))))),
Daniel Jaspera7564432012-09-13 13:11:25 +00002918 new VerifyIdIsBoundTo<FieldDecl>("f", 8)));
Manuel Klimek4da21662012-07-06 05:48:52 +00002919}
2920
Daniel Jasper11c98772012-11-11 22:14:55 +00002921TEST(ForEachDescendant, BindsCorrectNodes) {
2922 EXPECT_TRUE(matchAndVerifyResultTrue(
2923 "class C { void f(); int i; };",
2924 recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
2925 new VerifyIdIsBoundTo<FieldDecl>("decl", 1)));
2926 EXPECT_TRUE(matchAndVerifyResultTrue(
2927 "class C { void f() {} int i; };",
2928 recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
2929 new VerifyIdIsBoundTo<FunctionDecl>("decl", 1)));
2930}
2931
Manuel Klimek152ea0e2013-02-04 10:59:20 +00002932TEST(FindAll, BindsNodeOnMatch) {
2933 EXPECT_TRUE(matchAndVerifyResultTrue(
2934 "class A {};",
2935 recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
2936 new VerifyIdIsBoundTo<CXXRecordDecl>("v", 1)));
2937}
2938
2939TEST(FindAll, BindsDescendantNodeOnMatch) {
2940 EXPECT_TRUE(matchAndVerifyResultTrue(
2941 "class A { int a; int b; };",
2942 recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
2943 new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
2944}
2945
2946TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
2947 EXPECT_TRUE(matchAndVerifyResultTrue(
2948 "class A { int a; int b; };",
2949 recordDecl(hasName("::A"),
2950 findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
2951 fieldDecl().bind("v"))))),
2952 new VerifyIdIsBoundTo<Decl>("v", 3)));
2953
2954 EXPECT_TRUE(matchAndVerifyResultTrue(
2955 "class A { class B {}; class C {}; };",
2956 recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
2957 new VerifyIdIsBoundTo<CXXRecordDecl>("v", 3)));
2958}
2959
Manuel Klimek73876732013-02-04 09:42:38 +00002960TEST(EachOf, TriggersForEachMatch) {
2961 EXPECT_TRUE(matchAndVerifyResultTrue(
2962 "class A { int a; int b; };",
2963 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
2964 has(fieldDecl(hasName("b")).bind("v")))),
2965 new VerifyIdIsBoundTo<FieldDecl>("v", 2)));
2966}
2967
2968TEST(EachOf, BehavesLikeAnyOfUnlessBothMatch) {
2969 EXPECT_TRUE(matchAndVerifyResultTrue(
2970 "class A { int a; int c; };",
2971 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
2972 has(fieldDecl(hasName("b")).bind("v")))),
2973 new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
2974 EXPECT_TRUE(matchAndVerifyResultTrue(
2975 "class A { int c; int b; };",
2976 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
2977 has(fieldDecl(hasName("b")).bind("v")))),
2978 new VerifyIdIsBoundTo<FieldDecl>("v", 1)));
2979 EXPECT_TRUE(notMatches(
2980 "class A { int c; int d; };",
2981 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
2982 has(fieldDecl(hasName("b")).bind("v"))))));
2983}
Manuel Klimek4da21662012-07-06 05:48:52 +00002984
2985TEST(IsTemplateInstantiation, MatchesImplicitClassTemplateInstantiation) {
2986 // Make sure that we can both match the class by name (::X) and by the type
2987 // the template was instantiated with (via a field).
2988
2989 EXPECT_TRUE(matches(
2990 "template <typename T> class X {}; class A {}; X<A> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002991 recordDecl(hasName("::X"), isTemplateInstantiation())));
Manuel Klimek4da21662012-07-06 05:48:52 +00002992
2993 EXPECT_TRUE(matches(
2994 "template <typename T> class X { T t; }; class A {}; X<A> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00002995 recordDecl(isTemplateInstantiation(), hasDescendant(
2996 fieldDecl(hasType(recordDecl(hasName("A"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00002997}
2998
2999TEST(IsTemplateInstantiation, MatchesImplicitFunctionTemplateInstantiation) {
3000 EXPECT_TRUE(matches(
3001 "template <typename T> void f(T t) {} class A {}; void g() { f(A()); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003002 functionDecl(hasParameter(0, hasType(recordDecl(hasName("A")))),
Manuel Klimek4da21662012-07-06 05:48:52 +00003003 isTemplateInstantiation())));
3004}
3005
3006TEST(IsTemplateInstantiation, MatchesExplicitClassTemplateInstantiation) {
3007 EXPECT_TRUE(matches(
3008 "template <typename T> class X { T t; }; class A {};"
3009 "template class X<A>;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003010 recordDecl(isTemplateInstantiation(), hasDescendant(
3011 fieldDecl(hasType(recordDecl(hasName("A"))))))));
Manuel Klimek4da21662012-07-06 05:48:52 +00003012}
3013
3014TEST(IsTemplateInstantiation,
3015 MatchesInstantiationOfPartiallySpecializedClassTemplate) {
3016 EXPECT_TRUE(matches(
3017 "template <typename T> class X {};"
3018 "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003019 recordDecl(hasName("::X"), isTemplateInstantiation())));
Manuel Klimek4da21662012-07-06 05:48:52 +00003020}
3021
3022TEST(IsTemplateInstantiation,
3023 MatchesInstantiationOfClassTemplateNestedInNonTemplate) {
3024 EXPECT_TRUE(matches(
3025 "class A {};"
3026 "class X {"
3027 " template <typename U> class Y { U u; };"
3028 " Y<A> y;"
3029 "};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003030 recordDecl(hasName("::X::Y"), isTemplateInstantiation())));
Manuel Klimek4da21662012-07-06 05:48:52 +00003031}
3032
3033TEST(IsTemplateInstantiation, DoesNotMatchInstantiationsInsideOfInstantiation) {
3034 // FIXME: Figure out whether this makes sense. It doesn't affect the
3035 // normal use case as long as the uppermost instantiation always is marked
3036 // as template instantiation, but it might be confusing as a predicate.
3037 EXPECT_TRUE(matches(
3038 "class A {};"
3039 "template <typename T> class X {"
3040 " template <typename U> class Y { U u; };"
3041 " Y<T> y;"
3042 "}; X<A> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003043 recordDecl(hasName("::X<A>::Y"), unless(isTemplateInstantiation()))));
Manuel Klimek4da21662012-07-06 05:48:52 +00003044}
3045
3046TEST(IsTemplateInstantiation, DoesNotMatchExplicitClassTemplateSpecialization) {
3047 EXPECT_TRUE(notMatches(
3048 "template <typename T> class X {}; class A {};"
3049 "template <> class X<A> {}; X<A> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003050 recordDecl(hasName("::X"), isTemplateInstantiation())));
Manuel Klimek4da21662012-07-06 05:48:52 +00003051}
3052
3053TEST(IsTemplateInstantiation, DoesNotMatchNonTemplate) {
3054 EXPECT_TRUE(notMatches(
3055 "class A {}; class Y { A a; };",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003056 recordDecl(isTemplateInstantiation())));
Manuel Klimek4da21662012-07-06 05:48:52 +00003057}
3058
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003059TEST(IsExplicitTemplateSpecialization,
3060 DoesNotMatchPrimaryTemplate) {
3061 EXPECT_TRUE(notMatches(
3062 "template <typename T> class X {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003063 recordDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003064 EXPECT_TRUE(notMatches(
3065 "template <typename T> void f(T t);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003066 functionDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003067}
3068
3069TEST(IsExplicitTemplateSpecialization,
3070 DoesNotMatchExplicitTemplateInstantiations) {
3071 EXPECT_TRUE(notMatches(
3072 "template <typename T> class X {};"
3073 "template class X<int>; extern template class X<long>;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003074 recordDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003075 EXPECT_TRUE(notMatches(
3076 "template <typename T> void f(T t) {}"
3077 "template void f(int t); extern template void f(long t);",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003078 functionDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003079}
3080
3081TEST(IsExplicitTemplateSpecialization,
3082 DoesNotMatchImplicitTemplateInstantiations) {
3083 EXPECT_TRUE(notMatches(
3084 "template <typename T> class X {}; X<int> x;",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003085 recordDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003086 EXPECT_TRUE(notMatches(
3087 "template <typename T> void f(T t); void g() { f(10); }",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003088 functionDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003089}
3090
3091TEST(IsExplicitTemplateSpecialization,
3092 MatchesExplicitTemplateSpecializations) {
3093 EXPECT_TRUE(matches(
3094 "template <typename T> class X {};"
3095 "template<> class X<int> {};",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003096 recordDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003097 EXPECT_TRUE(matches(
3098 "template <typename T> void f(T t) {}"
3099 "template<> void f(int t) {}",
Daniel Jasper2dc75ed2012-08-24 05:12:34 +00003100 functionDecl(isExplicitTemplateSpecialization())));
Dmitri Gribenko8456ae62012-08-17 18:42:47 +00003101}
3102
Manuel Klimek579b1202012-09-07 09:26:10 +00003103TEST(HasAncenstor, MatchesDeclarationAncestors) {
3104 EXPECT_TRUE(matches(
3105 "class A { class B { class C {}; }; };",
3106 recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("A"))))));
3107}
3108
3109TEST(HasAncenstor, FailsIfNoAncestorMatches) {
3110 EXPECT_TRUE(notMatches(
3111 "class A { class B { class C {}; }; };",
3112 recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("X"))))));
3113}
3114
3115TEST(HasAncestor, MatchesDeclarationsThatGetVisitedLater) {
3116 EXPECT_TRUE(matches(
3117 "class A { class B { void f() { C c; } class C {}; }; };",
3118 varDecl(hasName("c"), hasType(recordDecl(hasName("C"),
3119 hasAncestor(recordDecl(hasName("A"))))))));
3120}
3121
3122TEST(HasAncenstor, MatchesStatementAncestors) {
3123 EXPECT_TRUE(matches(
3124 "void f() { if (true) { while (false) { 42; } } }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00003125 integerLiteral(equals(42), hasAncestor(ifStmt()))));
Manuel Klimek579b1202012-09-07 09:26:10 +00003126}
3127
3128TEST(HasAncestor, DrillsThroughDifferentHierarchies) {
3129 EXPECT_TRUE(matches(
3130 "void f() { if (true) { int x = 42; } }",
Daniel Jasper3680b4f2012-09-18 13:09:13 +00003131 integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
Manuel Klimek579b1202012-09-07 09:26:10 +00003132}
3133
3134TEST(HasAncestor, BindsRecursiveCombinations) {
3135 EXPECT_TRUE(matchAndVerifyResultTrue(
3136 "class C { class D { class E { class F { int y; }; }; }; };",
3137 fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
Daniel Jaspera7564432012-09-13 13:11:25 +00003138 new VerifyIdIsBoundTo<CXXRecordDecl>("r", 1)));
Manuel Klimek579b1202012-09-07 09:26:10 +00003139}
3140
3141TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
3142 EXPECT_TRUE(matchAndVerifyResultTrue(
3143 "class C { class D { class E { class F { int y; }; }; }; };",
3144 fieldDecl(hasAncestor(
3145 decl(
3146 hasDescendant(recordDecl(isDefinition(),
3147 hasAncestor(recordDecl())))
3148 ).bind("d")
3149 )),
Daniel Jaspera7564432012-09-13 13:11:25 +00003150 new VerifyIdIsBoundTo<CXXRecordDecl>("d", "E")));
Manuel Klimek579b1202012-09-07 09:26:10 +00003151}
3152
3153TEST(HasAncestor, MatchesInTemplateInstantiations) {
3154 EXPECT_TRUE(matches(
3155 "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
3156 "A<int>::B::C a;",
3157 fieldDecl(hasType(asString("int")),
3158 hasAncestor(recordDecl(hasName("A"))))));
3159}
3160
3161TEST(HasAncestor, MatchesInImplicitCode) {
3162 EXPECT_TRUE(matches(
3163 "struct X {}; struct A { A() {} X x; };",
3164 constructorDecl(
3165 hasAnyConstructorInitializer(withInitializer(expr(
3166 hasAncestor(recordDecl(hasName("A")))))))));
3167}
3168
Daniel Jasperc99a3ad2012-10-22 16:26:51 +00003169TEST(HasParent, MatchesOnlyParent) {
3170 EXPECT_TRUE(matches(
3171 "void f() { if (true) { int x = 42; } }",
3172 compoundStmt(hasParent(ifStmt()))));
3173 EXPECT_TRUE(notMatches(
3174 "void f() { for (;;) { int x = 42; } }",
3175 compoundStmt(hasParent(ifStmt()))));
3176 EXPECT_TRUE(notMatches(
3177 "void f() { if (true) for (;;) { int x = 42; } }",
3178 compoundStmt(hasParent(ifStmt()))));
3179}
3180
Manuel Klimek30ace372012-12-06 14:42:48 +00003181TEST(HasAncestor, MatchesAllAncestors) {
3182 EXPECT_TRUE(matches(
3183 "template <typename T> struct C { static void f() { 42; } };"
3184 "void t() { C<int>::f(); }",
3185 integerLiteral(
3186 equals(42),
3187 allOf(hasAncestor(recordDecl(isTemplateInstantiation())),
3188 hasAncestor(recordDecl(unless(isTemplateInstantiation())))))));
3189}
3190
3191TEST(HasParent, MatchesAllParents) {
3192 EXPECT_TRUE(matches(
3193 "template <typename T> struct C { static void f() { 42; } };"
3194 "void t() { C<int>::f(); }",
3195 integerLiteral(
3196 equals(42),
3197 hasParent(compoundStmt(hasParent(functionDecl(
3198 hasParent(recordDecl(isTemplateInstantiation())))))))));
3199 EXPECT_TRUE(matches(
3200 "template <typename T> struct C { static void f() { 42; } };"
3201 "void t() { C<int>::f(); }",
3202 integerLiteral(
3203 equals(42),
3204 hasParent(compoundStmt(hasParent(functionDecl(
3205 hasParent(recordDecl(unless(isTemplateInstantiation()))))))))));
3206 EXPECT_TRUE(matches(
3207 "template <typename T> struct C { static void f() { 42; } };"
3208 "void t() { C<int>::f(); }",
3209 integerLiteral(equals(42),
3210 hasParent(compoundStmt(allOf(
3211 hasParent(functionDecl(
3212 hasParent(recordDecl(isTemplateInstantiation())))),
3213 hasParent(functionDecl(hasParent(recordDecl(
3214 unless(isTemplateInstantiation())))))))))));
3215}
3216
Daniel Jasperce620072012-10-17 08:52:59 +00003217TEST(TypeMatching, MatchesTypes) {
3218 EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
3219}
3220
3221TEST(TypeMatching, MatchesArrayTypes) {
3222 EXPECT_TRUE(matches("int a[] = {2,3};", arrayType()));
3223 EXPECT_TRUE(matches("int a[42];", arrayType()));
3224 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", arrayType()));
3225
3226 EXPECT_TRUE(notMatches("struct A {}; A a[7];",
3227 arrayType(hasElementType(builtinType()))));
3228
3229 EXPECT_TRUE(matches(
3230 "int const a[] = { 2, 3 };",
3231 qualType(arrayType(hasElementType(builtinType())))));
3232 EXPECT_TRUE(matches(
3233 "int const a[] = { 2, 3 };",
3234 qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
3235 EXPECT_TRUE(matches(
3236 "typedef const int T; T x[] = { 1, 2 };",
3237 qualType(isConstQualified(), arrayType())));
3238
3239 EXPECT_TRUE(notMatches(
3240 "int a[] = { 2, 3 };",
3241 qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
3242 EXPECT_TRUE(notMatches(
3243 "int a[] = { 2, 3 };",
3244 qualType(arrayType(hasElementType(isConstQualified(), builtinType())))));
3245 EXPECT_TRUE(notMatches(
3246 "int const a[] = { 2, 3 };",
3247 qualType(arrayType(hasElementType(builtinType())),
3248 unless(isConstQualified()))));
3249
3250 EXPECT_TRUE(matches("int a[2];",
3251 constantArrayType(hasElementType(builtinType()))));
3252 EXPECT_TRUE(matches("const int a = 0;", qualType(isInteger())));
3253}
3254
3255TEST(TypeMatching, MatchesComplexTypes) {
3256 EXPECT_TRUE(matches("_Complex float f;", complexType()));
3257 EXPECT_TRUE(matches(
3258 "_Complex float f;",
3259 complexType(hasElementType(builtinType()))));
3260 EXPECT_TRUE(notMatches(
3261 "_Complex float f;",
3262 complexType(hasElementType(isInteger()))));
3263}
3264
3265TEST(TypeMatching, MatchesConstantArrayTypes) {
3266 EXPECT_TRUE(matches("int a[2];", constantArrayType()));
3267 EXPECT_TRUE(notMatches(
3268 "void f() { int a[] = { 2, 3 }; int b[a[0]]; }",
3269 constantArrayType(hasElementType(builtinType()))));
3270
3271 EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));
3272 EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
3273 EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));
3274}
3275
3276TEST(TypeMatching, MatchesDependentSizedArrayTypes) {
3277 EXPECT_TRUE(matches(
3278 "template <typename T, int Size> class array { T data[Size]; };",
3279 dependentSizedArrayType()));
3280 EXPECT_TRUE(notMatches(
3281 "int a[42]; int b[] = { 2, 3 }; void f() { int c[b[0]]; }",
3282 dependentSizedArrayType()));
3283}
3284
3285TEST(TypeMatching, MatchesIncompleteArrayType) {
3286 EXPECT_TRUE(matches("int a[] = { 2, 3 };", incompleteArrayType()));
3287 EXPECT_TRUE(matches("void f(int a[]) {}", incompleteArrayType()));
3288
3289 EXPECT_TRUE(notMatches("int a[42]; void f() { int b[a[0]]; }",
3290 incompleteArrayType()));
3291}
3292
3293TEST(TypeMatching, MatchesVariableArrayType) {
3294 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", variableArrayType()));
3295 EXPECT_TRUE(notMatches("int a[] = {2, 3}; int b[42];", variableArrayType()));
3296
3297 EXPECT_TRUE(matches(
3298 "void f(int b) { int a[b]; }",
3299 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
3300 varDecl(hasName("b")))))))));
3301}
3302
3303TEST(TypeMatching, MatchesAtomicTypes) {
3304 EXPECT_TRUE(matches("_Atomic(int) i;", atomicType()));
3305
3306 EXPECT_TRUE(matches("_Atomic(int) i;",
3307 atomicType(hasValueType(isInteger()))));
3308 EXPECT_TRUE(notMatches("_Atomic(float) f;",
3309 atomicType(hasValueType(isInteger()))));
3310}
3311
3312TEST(TypeMatching, MatchesAutoTypes) {
3313 EXPECT_TRUE(matches("auto i = 2;", autoType()));
3314 EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
3315 autoType()));
3316
3317 EXPECT_TRUE(matches("auto a = 1;",
3318 autoType(hasDeducedType(isInteger()))));
3319 EXPECT_TRUE(notMatches("auto b = 2.0;",
3320 autoType(hasDeducedType(isInteger()))));
3321}
3322
Daniel Jaspera267cf62012-10-29 10:14:44 +00003323TEST(TypeMatching, MatchesFunctionTypes) {
3324 EXPECT_TRUE(matches("int (*f)(int);", functionType()));
3325 EXPECT_TRUE(matches("void f(int i) {}", functionType()));
3326}
3327
Daniel Jasperce620072012-10-17 08:52:59 +00003328TEST(TypeMatching, PointerTypes) {
Daniel Jasper1802daf2012-10-17 13:35:36 +00003329 // FIXME: Reactive when these tests can be more specific (not matching
3330 // implicit code on certain platforms), likely when we have hasDescendant for
3331 // Types/TypeLocs.
3332 //EXPECT_TRUE(matchAndVerifyResultTrue(
3333 // "int* a;",
3334 // pointerTypeLoc(pointeeLoc(typeLoc().bind("loc"))),
3335 // new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
3336 //EXPECT_TRUE(matchAndVerifyResultTrue(
3337 // "int* a;",
3338 // pointerTypeLoc().bind("loc"),
3339 // new VerifyIdIsBoundTo<TypeLoc>("loc", 1)));
Daniel Jasperce620072012-10-17 08:52:59 +00003340 EXPECT_TRUE(matches(
3341 "int** a;",
David Blaikie5be093c2013-02-18 19:04:16 +00003342 loc(pointerType(pointee(qualType())))));
Daniel Jasperce620072012-10-17 08:52:59 +00003343 EXPECT_TRUE(matches(
3344 "int** a;",
3345 loc(pointerType(pointee(pointerType())))));
3346 EXPECT_TRUE(matches(
3347 "int* b; int* * const a = &b;",
3348 loc(qualType(isConstQualified(), pointerType()))));
3349
3350 std::string Fragment = "struct A { int i; }; int A::* ptr = &A::i;";
Daniel Jasper1802daf2012-10-17 13:35:36 +00003351 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3352 hasType(blockPointerType()))));
3353 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
3354 hasType(memberPointerType()))));
3355 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3356 hasType(pointerType()))));
3357 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3358 hasType(referenceType()))));
Daniel Jasperce620072012-10-17 08:52:59 +00003359
Daniel Jasper1802daf2012-10-17 13:35:36 +00003360 Fragment = "int *ptr;";
3361 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3362 hasType(blockPointerType()))));
3363 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3364 hasType(memberPointerType()))));
3365 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
3366 hasType(pointerType()))));
3367 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
3368 hasType(referenceType()))));
Daniel Jasperce620072012-10-17 08:52:59 +00003369
Daniel Jasper1802daf2012-10-17 13:35:36 +00003370 Fragment = "int a; int &ref = a;";
3371 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3372 hasType(blockPointerType()))));
3373 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3374 hasType(memberPointerType()))));
3375 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
3376 hasType(pointerType()))));
3377 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
3378 hasType(referenceType()))));
Daniel Jasperce620072012-10-17 08:52:59 +00003379}
3380
3381TEST(TypeMatching, PointeeTypes) {
3382 EXPECT_TRUE(matches("int b; int &a = b;",
3383 referenceType(pointee(builtinType()))));
3384 EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));
3385
3386 EXPECT_TRUE(matches("int *a;",
David Blaikie5be093c2013-02-18 19:04:16 +00003387 loc(pointerType(pointee(builtinType())))));
Daniel Jasperce620072012-10-17 08:52:59 +00003388
3389 EXPECT_TRUE(matches(
3390 "int const *A;",
3391 pointerType(pointee(isConstQualified(), builtinType()))));
3392 EXPECT_TRUE(notMatches(
3393 "int *A;",
3394 pointerType(pointee(isConstQualified(), builtinType()))));
3395}
3396
3397TEST(TypeMatching, MatchesPointersToConstTypes) {
3398 EXPECT_TRUE(matches("int b; int * const a = &b;",
3399 loc(pointerType())));
3400 EXPECT_TRUE(matches("int b; int * const a = &b;",
David Blaikie5be093c2013-02-18 19:04:16 +00003401 loc(pointerType())));
Daniel Jasperce620072012-10-17 08:52:59 +00003402 EXPECT_TRUE(matches(
3403 "int b; const int * a = &b;",
David Blaikie5be093c2013-02-18 19:04:16 +00003404 loc(pointerType(pointee(builtinType())))));
Daniel Jasperce620072012-10-17 08:52:59 +00003405 EXPECT_TRUE(matches(
3406 "int b; const int * a = &b;",
3407 pointerType(pointee(builtinType()))));
3408}
3409
3410TEST(TypeMatching, MatchesTypedefTypes) {
Daniel Jasper1802daf2012-10-17 13:35:36 +00003411 EXPECT_TRUE(matches("typedef int X; X a;", varDecl(hasName("a"),
3412 hasType(typedefType()))));
Daniel Jasperce620072012-10-17 08:52:59 +00003413}
3414
Edwin Vane3abf7782013-02-25 14:49:29 +00003415TEST(TypeMatching, MatchesTemplateSpecializationType) {
3416 EXPECT_TRUE(matches("template <typename T> class A{}; A<int>a;",
3417 templateSpecializationType()));
3418}
3419
Daniel Jaspera7564432012-09-13 13:11:25 +00003420TEST(NNS, MatchesNestedNameSpecifiers) {
3421 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;",
3422 nestedNameSpecifier()));
3423 EXPECT_TRUE(matches("template <typename T> class A { typename T::B b; };",
3424 nestedNameSpecifier()));
3425 EXPECT_TRUE(matches("struct A { void f(); }; void A::f() {}",
3426 nestedNameSpecifier()));
3427
3428 EXPECT_TRUE(matches(
3429 "struct A { static void f() {} }; void g() { A::f(); }",
3430 nestedNameSpecifier()));
3431 EXPECT_TRUE(notMatches(
3432 "struct A { static void f() {} }; void g(A* a) { a->f(); }",
3433 nestedNameSpecifier()));
3434}
3435
Daniel Jasperb54b7642012-09-20 14:12:57 +00003436TEST(NullStatement, SimpleCases) {
3437 EXPECT_TRUE(matches("void f() {int i;;}", nullStmt()));
3438 EXPECT_TRUE(notMatches("void f() {int i;}", nullStmt()));
3439}
3440
Daniel Jaspera7564432012-09-13 13:11:25 +00003441TEST(NNS, MatchesTypes) {
3442 NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
3443 specifiesType(hasDeclaration(recordDecl(hasName("A")))));
3444 EXPECT_TRUE(matches("struct A { struct B {}; }; A::B b;", Matcher));
3445 EXPECT_TRUE(matches("struct A { struct B { struct C {}; }; }; A::B::C c;",
3446 Matcher));
3447 EXPECT_TRUE(notMatches("namespace A { struct B {}; } A::B b;", Matcher));
3448}
3449
3450TEST(NNS, MatchesNamespaceDecls) {
3451 NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
3452 specifiesNamespace(hasName("ns")));
3453 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;", Matcher));
3454 EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
3455 EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
3456}
3457
3458TEST(NNS, BindsNestedNameSpecifiers) {
3459 EXPECT_TRUE(matchAndVerifyResultTrue(
3460 "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
3461 nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
3462 new VerifyIdIsBoundTo<NestedNameSpecifier>("nns", "ns::struct E::")));
3463}
3464
3465TEST(NNS, BindsNestedNameSpecifierLocs) {
3466 EXPECT_TRUE(matchAndVerifyResultTrue(
3467 "namespace ns { struct B {}; } ns::B b;",
3468 loc(nestedNameSpecifier()).bind("loc"),
3469 new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("loc", 1)));
3470}
3471
3472TEST(NNS, MatchesNestedNameSpecifierPrefixes) {
3473 EXPECT_TRUE(matches(
3474 "struct A { struct B { struct C {}; }; }; A::B::C c;",
3475 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A"))))));
3476 EXPECT_TRUE(matches(
3477 "struct A { struct B { struct C {}; }; }; A::B::C c;",
Daniel Jasperce620072012-10-17 08:52:59 +00003478 nestedNameSpecifierLoc(hasPrefix(
3479 specifiesTypeLoc(loc(qualType(asString("struct A"))))))));
Daniel Jaspera7564432012-09-13 13:11:25 +00003480}
3481
Daniel Jasperd1ce3c12012-10-30 15:42:00 +00003482TEST(NNS, DescendantsOfNestedNameSpecifiers) {
3483 std::string Fragment =
3484 "namespace a { struct A { struct B { struct C {}; }; }; };"
3485 "void f() { a::A::B::C c; }";
3486 EXPECT_TRUE(matches(
3487 Fragment,
3488 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
3489 hasDescendant(nestedNameSpecifier(
3490 specifiesNamespace(hasName("a")))))));
3491 EXPECT_TRUE(notMatches(
3492 Fragment,
3493 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
3494 has(nestedNameSpecifier(
3495 specifiesNamespace(hasName("a")))))));
3496 EXPECT_TRUE(matches(
3497 Fragment,
3498 nestedNameSpecifier(specifiesType(asString("struct a::A")),
3499 has(nestedNameSpecifier(
3500 specifiesNamespace(hasName("a")))))));
3501
3502 // Not really useful because a NestedNameSpecifier can af at most one child,
3503 // but to complete the interface.
3504 EXPECT_TRUE(matchAndVerifyResultTrue(
3505 Fragment,
3506 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
3507 forEach(nestedNameSpecifier().bind("x"))),
3508 new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 1)));
3509}
3510
3511TEST(NNS, NestedNameSpecifiersAsDescendants) {
3512 std::string Fragment =
3513 "namespace a { struct A { struct B { struct C {}; }; }; };"
3514 "void f() { a::A::B::C c; }";
3515 EXPECT_TRUE(matches(
3516 Fragment,
3517 decl(hasDescendant(nestedNameSpecifier(specifiesType(
3518 asString("struct a::A")))))));
3519 EXPECT_TRUE(matchAndVerifyResultTrue(
3520 Fragment,
3521 functionDecl(hasName("f"),
3522 forEachDescendant(nestedNameSpecifier().bind("x"))),
3523 // Nested names: a, a::A and a::A::B.
3524 new VerifyIdIsBoundTo<NestedNameSpecifier>("x", 3)));
3525}
3526
3527TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
3528 std::string Fragment =
3529 "namespace a { struct A { struct B { struct C {}; }; }; };"
3530 "void f() { a::A::B::C c; }";
3531 EXPECT_TRUE(matches(
3532 Fragment,
3533 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
3534 hasDescendant(loc(nestedNameSpecifier(
3535 specifiesNamespace(hasName("a"))))))));
3536 EXPECT_TRUE(notMatches(
3537 Fragment,
3538 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
3539 has(loc(nestedNameSpecifier(
3540 specifiesNamespace(hasName("a"))))))));
3541 EXPECT_TRUE(matches(
3542 Fragment,
3543 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
3544 has(loc(nestedNameSpecifier(
3545 specifiesNamespace(hasName("a"))))))));
3546
3547 EXPECT_TRUE(matchAndVerifyResultTrue(
3548 Fragment,
3549 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
3550 forEach(nestedNameSpecifierLoc().bind("x"))),
3551 new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 1)));
3552}
3553
3554TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
3555 std::string Fragment =
3556 "namespace a { struct A { struct B { struct C {}; }; }; };"
3557 "void f() { a::A::B::C c; }";
3558 EXPECT_TRUE(matches(
3559 Fragment,
3560 decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
3561 asString("struct a::A"))))))));
3562 EXPECT_TRUE(matchAndVerifyResultTrue(
3563 Fragment,
3564 functionDecl(hasName("f"),
3565 forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
3566 // Nested names: a, a::A and a::A::B.
3567 new VerifyIdIsBoundTo<NestedNameSpecifierLoc>("x", 3)));
3568}
3569
Manuel Klimek60969f52013-02-01 13:41:35 +00003570template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003571public:
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003572 VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
3573 StringRef InnerId)
3574 : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
Daniel Jasper452abbc2012-10-29 10:48:25 +00003575 }
3576
Manuel Klimek60969f52013-02-01 13:41:35 +00003577 virtual bool run(const BoundNodes *Nodes) { return false; }
3578
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003579 virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
3580 const T *Node = Nodes->getNodeAs<T>(Id);
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003581 return selectFirst<const T>(InnerId,
3582 match(InnerMatcher, *Node, *Context)) != NULL;
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003583 }
3584private:
3585 std::string Id;
3586 internal::Matcher<T> InnerMatcher;
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003587 std::string InnerId;
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003588};
3589
3590TEST(MatchFinder, CanMatchDeclarationsRecursively) {
Manuel Klimek60969f52013-02-01 13:41:35 +00003591 EXPECT_TRUE(matchAndVerifyResultTrue(
3592 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
3593 new VerifyMatchOnNode<clang::Decl>(
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003594 "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
3595 "Y")));
Manuel Klimek60969f52013-02-01 13:41:35 +00003596 EXPECT_TRUE(matchAndVerifyResultFalse(
3597 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
3598 new VerifyMatchOnNode<clang::Decl>(
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003599 "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
3600 "Z")));
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003601}
3602
3603TEST(MatchFinder, CanMatchStatementsRecursively) {
Manuel Klimek60969f52013-02-01 13:41:35 +00003604 EXPECT_TRUE(matchAndVerifyResultTrue(
3605 "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003606 new VerifyMatchOnNode<clang::Stmt>(
3607 "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
Manuel Klimek60969f52013-02-01 13:41:35 +00003608 EXPECT_TRUE(matchAndVerifyResultFalse(
3609 "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003610 new VerifyMatchOnNode<clang::Stmt>(
3611 "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
Manuel Klimek60969f52013-02-01 13:41:35 +00003612}
3613
3614TEST(MatchFinder, CanMatchSingleNodesRecursively) {
3615 EXPECT_TRUE(matchAndVerifyResultTrue(
3616 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
3617 new VerifyMatchOnNode<clang::Decl>(
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003618 "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
Manuel Klimek60969f52013-02-01 13:41:35 +00003619 EXPECT_TRUE(matchAndVerifyResultFalse(
3620 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
3621 new VerifyMatchOnNode<clang::Decl>(
Manuel Klimekcf87bff2013-02-06 10:33:21 +00003622 "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
Manuel Klimek3e2aa992012-10-24 14:47:44 +00003623}
3624
Manuel Klimekfa37c5c2013-02-07 12:42:10 +00003625template <typename T>
3626class VerifyAncestorHasChildIsEqual : public BoundNodesCallback {
3627public:
3628 virtual bool run(const BoundNodes *Nodes) { return false; }
3629
3630 virtual bool run(const BoundNodes *Nodes, ASTContext *Context) {
3631 const T *Node = Nodes->getNodeAs<T>("");
3632 return verify(*Nodes, *Context, Node);
3633 }
3634
3635 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Stmt *Node) {
3636 return selectFirst<const T>(
3637 "", match(stmt(hasParent(stmt(has(stmt(equalsNode(Node)))).bind(""))),
3638 *Node, Context)) != NULL;
3639 }
3640 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Decl *Node) {
3641 return selectFirst<const T>(
3642 "", match(decl(hasParent(decl(has(decl(equalsNode(Node)))).bind(""))),
3643 *Node, Context)) != NULL;
3644 }
3645};
3646
3647TEST(IsEqualTo, MatchesNodesByIdentity) {
3648 EXPECT_TRUE(matchAndVerifyResultTrue(
3649 "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
3650 new VerifyAncestorHasChildIsEqual<Decl>()));
3651 EXPECT_TRUE(
3652 matchAndVerifyResultTrue("void f() { if(true) {} }", ifStmt().bind(""),
3653 new VerifyAncestorHasChildIsEqual<Stmt>()));
3654}
3655
Manuel Klimeke5793282012-11-02 01:31:03 +00003656class VerifyStartOfTranslationUnit : public MatchFinder::MatchCallback {
3657public:
3658 VerifyStartOfTranslationUnit() : Called(false) {}
3659 virtual void run(const MatchFinder::MatchResult &Result) {
3660 EXPECT_TRUE(Called);
3661 }
3662 virtual void onStartOfTranslationUnit() {
3663 Called = true;
3664 }
3665 bool Called;
3666};
3667
3668TEST(MatchFinder, InterceptsStartOfTranslationUnit) {
3669 MatchFinder Finder;
3670 VerifyStartOfTranslationUnit VerifyCallback;
3671 Finder.addMatcher(decl(), &VerifyCallback);
3672 OwningPtr<FrontendActionFactory> Factory(newFrontendActionFactory(&Finder));
3673 ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), "int x;"));
3674 EXPECT_TRUE(VerifyCallback.Called);
3675}
3676
Manuel Klimek4da21662012-07-06 05:48:52 +00003677} // end namespace ast_matchers
3678} // end namespace clang