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