Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 71f1c643201bf48a6fe5593abd110652ce0acde8 / . / clang / unittests / ASTMatchers / ASTMatchersNarrowingTest.cpp
blob: 5834211bdb0e2e7fa3cc220306b9499b7aaf3ae3 [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 =
672 "void f() { int x; static int y; } int a;";
673
674 EXPECT_TRUE(matches(T, varDecl(hasName("x"), hasAutomaticStorageDuration())));
675 EXPECT_TRUE(
676 notMatches(T, varDecl(hasName("y"), hasAutomaticStorageDuration())));
677 EXPECT_TRUE(
678 notMatches(T, varDecl(hasName("a"), hasAutomaticStorageDuration())));
679
680 EXPECT_TRUE(matches(T, varDecl(hasName("y"), hasStaticStorageDuration())));
681 EXPECT_TRUE(matches(T, varDecl(hasName("a"), hasStaticStorageDuration())));
682 EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasStaticStorageDuration())));
683
684 // FIXME: It is really hard to test with thread_local itself because not all
685 // targets support TLS, which causes this to be an error depending on what
686 // platform the test is being run on. We do not have access to the TargetInfo
687 // object to be able to test whether the platform supports TLS or not.
688 EXPECT_TRUE(notMatches(T, varDecl(hasName("x"), hasThreadStorageDuration())));
689 EXPECT_TRUE(notMatches(T, varDecl(hasName("y"), hasThreadStorageDuration())));
690 EXPECT_TRUE(notMatches(T, varDecl(hasName("a"), hasThreadStorageDuration())));
691}
692
693TEST(Matcher, FindsVarDeclInFunctionParameter) {
694 EXPECT_TRUE(matches(
695 "void f(int i) {}",
696 varDecl(hasName("i"))));
697}
698
699TEST(UnaryExpressionOrTypeTraitExpression, MatchesCorrectType) {
700 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }", sizeOfExpr(
701 hasArgumentOfType(asString("int")))));
702 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
703 hasArgumentOfType(asString("float")))));
704 EXPECT_TRUE(matches(
705 "struct A {}; void x() { A a; int b = sizeof(a); }",
706 sizeOfExpr(hasArgumentOfType(hasDeclaration(recordDecl(hasName("A")))))));
707 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }", sizeOfExpr(
708 hasArgumentOfType(hasDeclaration(recordDecl(hasName("string")))))));
709}
710
711TEST(IsInteger, MatchesIntegers) {
712 EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isInteger()))));
713 EXPECT_TRUE(matches(
714 "long long i = 0; void f(long long) { }; void g() {f(i);}",
715 callExpr(hasArgument(0, declRefExpr(
716 to(varDecl(hasType(isInteger()))))))));
717}
718
719TEST(IsInteger, ReportsNoFalsePositives) {
720 EXPECT_TRUE(notMatches("int *i;", varDecl(hasType(isInteger()))));
721 EXPECT_TRUE(notMatches("struct T {}; T t; void f(T *) { }; void g() {f(&t);}",
722 callExpr(hasArgument(0, declRefExpr(
723 to(varDecl(hasType(isInteger()))))))));
724}
725
Clement Courbet42517592016-07-12 06:36:00 +0000[diff] [blame]726TEST(IsSignedInteger, MatchesSignedIntegers) {
727 EXPECT_TRUE(matches("int i = 0;", varDecl(hasType(isSignedInteger()))));
728 EXPECT_TRUE(notMatches("unsigned i = 0;",
729 varDecl(hasType(isSignedInteger()))));
730}
731
732TEST(IsUnsignedInteger, MatchesUnsignedIntegers) {
733 EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isUnsignedInteger()))));
734 EXPECT_TRUE(matches("unsigned i = 0;",
735 varDecl(hasType(isUnsignedInteger()))));
736}
737
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]738TEST(IsAnyPointer, MatchesPointers) {
739 EXPECT_TRUE(matches("int* i = nullptr;", varDecl(hasType(isAnyPointer()))));
740}
741
742TEST(IsAnyPointer, MatchesObjcPointer) {
743 EXPECT_TRUE(matchesObjC("@interface Foo @end Foo *f;",
744 varDecl(hasType(isAnyPointer()))));
745}
746
747TEST(IsAnyPointer, ReportsNoFalsePositives) {
748 EXPECT_TRUE(notMatches("int i = 0;", varDecl(hasType(isAnyPointer()))));
749}
750
751TEST(IsAnyCharacter, MatchesCharacters) {
752 EXPECT_TRUE(matches("char i = 0;", varDecl(hasType(isAnyCharacter()))));
753}
754
755TEST(IsAnyCharacter, ReportsNoFalsePositives) {
756 EXPECT_TRUE(notMatches("int i;", varDecl(hasType(isAnyCharacter()))));
757}
758
759TEST(IsArrow, MatchesMemberVariablesViaArrow) {
760 EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
761 memberExpr(isArrow())));
762 EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
763 memberExpr(isArrow())));
764 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
765 memberExpr(isArrow())));
766}
767
768TEST(IsArrow, MatchesStaticMemberVariablesViaArrow) {
769 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
770 memberExpr(isArrow())));
771 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
772 memberExpr(isArrow())));
773 EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
774 memberExpr(isArrow())));
775}
776
777TEST(IsArrow, MatchesMemberCallsViaArrow) {
778 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
779 memberExpr(isArrow())));
780 EXPECT_TRUE(matches("class Y { void x() { x(); } };",
781 memberExpr(isArrow())));
782 EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
783 memberExpr(isArrow())));
784}
785
786TEST(ConversionDeclaration, IsExplicit) {
787 EXPECT_TRUE(matches("struct S { explicit operator int(); };",
788 cxxConversionDecl(isExplicit())));
789 EXPECT_TRUE(notMatches("struct S { operator int(); };",
790 cxxConversionDecl(isExplicit())));
791}
792
793TEST(Matcher, ArgumentCount) {
794 StatementMatcher Call1Arg = callExpr(argumentCountIs(1));
795
796 EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
797 EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
798 EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
799}
800
801TEST(Matcher, ParameterCount) {
802 DeclarationMatcher Function1Arg = functionDecl(parameterCountIs(1));
803 EXPECT_TRUE(matches("void f(int i) {}", Function1Arg));
804 EXPECT_TRUE(matches("class X { void f(int i) {} };", Function1Arg));
805 EXPECT_TRUE(notMatches("void f() {}", Function1Arg));
806 EXPECT_TRUE(notMatches("void f(int i, int j, int k) {}", Function1Arg));
807 EXPECT_TRUE(matches("void f(int i, ...) {};", Function1Arg));
808}
809
810TEST(Matcher, References) {
811 DeclarationMatcher ReferenceClassX = varDecl(
812 hasType(references(recordDecl(hasName("X")))));
813 EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
814 ReferenceClassX));
815 EXPECT_TRUE(
816 matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
817 // The match here is on the implicit copy constructor code for
818 // class X, not on code 'X x = y'.
819 EXPECT_TRUE(
820 matches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
821 EXPECT_TRUE(
822 notMatches("class X {}; extern X x;", ReferenceClassX));
823 EXPECT_TRUE(
824 notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
825}
826
827TEST(QualType, hasLocalQualifiers) {
828 EXPECT_TRUE(notMatches("typedef const int const_int; const_int i = 1;",
829 varDecl(hasType(hasLocalQualifiers()))));
830 EXPECT_TRUE(matches("int *const j = nullptr;",
831 varDecl(hasType(hasLocalQualifiers()))));
832 EXPECT_TRUE(matches("int *volatile k;",
833 varDecl(hasType(hasLocalQualifiers()))));
834 EXPECT_TRUE(notMatches("int m;",
835 varDecl(hasType(hasLocalQualifiers()))));
836}
837
838TEST(IsExternC, MatchesExternCFunctionDeclarations) {
839 EXPECT_TRUE(matches("extern \"C\" void f() {}", functionDecl(isExternC())));
840 EXPECT_TRUE(matches("extern \"C\" { void f() {} }",
841 functionDecl(isExternC())));
842 EXPECT_TRUE(notMatches("void f() {}", functionDecl(isExternC())));
843}
844
Benjamin Kramer87e6d992016-08-04 10:02:03 +0000[diff] [blame]845TEST(IsExternC, MatchesExternCVariableDeclarations) {
846 EXPECT_TRUE(matches("extern \"C\" int i;", varDecl(isExternC())));
847 EXPECT_TRUE(matches("extern \"C\" { int i; }", varDecl(isExternC())));
848 EXPECT_TRUE(notMatches("int i;", varDecl(isExternC())));
849}
850
Haojian Wub3d25462016-09-26 16:01:52 +0000[diff] [blame]851TEST(IsStaticStorageClass, MatchesStaticDeclarations) {
852 EXPECT_TRUE(
853 matches("static void f() {}", functionDecl(isStaticStorageClass())));
854 EXPECT_TRUE(matches("static int i = 1;", varDecl(isStaticStorageClass())));
855 EXPECT_TRUE(notMatches("int i = 1;", varDecl(isStaticStorageClass())));
856 EXPECT_TRUE(notMatches("void f() {}", functionDecl(isStaticStorageClass())));
857}
858
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]859TEST(IsDefaulted, MatchesDefaultedFunctionDeclarations) {
860 EXPECT_TRUE(notMatches("class A { ~A(); };",
861 functionDecl(hasName("~A"), isDefaulted())));
862 EXPECT_TRUE(matches("class B { ~B() = default; };",
863 functionDecl(hasName("~B"), isDefaulted())));
864}
865
866TEST(IsDeleted, MatchesDeletedFunctionDeclarations) {
867 EXPECT_TRUE(
868 notMatches("void Func();", functionDecl(hasName("Func"), isDeleted())));
869 EXPECT_TRUE(matches("void Func() = delete;",
870 functionDecl(hasName("Func"), isDeleted())));
871}
872
873TEST(IsNoThrow, MatchesNoThrowFunctionDeclarations) {
874 EXPECT_TRUE(notMatches("void f();", functionDecl(isNoThrow())));
875 EXPECT_TRUE(notMatches("void f() throw(int);", functionDecl(isNoThrow())));
876 EXPECT_TRUE(
877 notMatches("void f() noexcept(false);", functionDecl(isNoThrow())));
878 EXPECT_TRUE(matches("void f() throw();", functionDecl(isNoThrow())));
879 EXPECT_TRUE(matches("void f() noexcept;", functionDecl(isNoThrow())));
Aaron Ballman230ad972016-06-07 17:34:45 +0000[diff] [blame]880
881 EXPECT_TRUE(notMatches("void f();", functionProtoType(isNoThrow())));
882 EXPECT_TRUE(notMatches("void f() throw(int);", functionProtoType(isNoThrow())));
883 EXPECT_TRUE(
884 notMatches("void f() noexcept(false);", functionProtoType(isNoThrow())));
885 EXPECT_TRUE(matches("void f() throw();", functionProtoType(isNoThrow())));
886 EXPECT_TRUE(matches("void f() noexcept;", functionProtoType(isNoThrow())));
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]887}
888
889TEST(isConstexpr, MatchesConstexprDeclarations) {
890 EXPECT_TRUE(matches("constexpr int foo = 42;",
891 varDecl(hasName("foo"), isConstexpr())));
892 EXPECT_TRUE(matches("constexpr int bar();",
893 functionDecl(hasName("bar"), isConstexpr())));
894}
895
896TEST(TemplateArgumentCountIs, Matches) {
897 EXPECT_TRUE(
898 matches("template<typename T> struct C {}; C<int> c;",
899 classTemplateSpecializationDecl(templateArgumentCountIs(1))));
900 EXPECT_TRUE(
901 notMatches("template<typename T> struct C {}; C<int> c;",
902 classTemplateSpecializationDecl(templateArgumentCountIs(2))));
903
904 EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
905 templateSpecializationType(templateArgumentCountIs(1))));
906 EXPECT_TRUE(
907 notMatches("template<typename T> struct C {}; C<int> c;",
908 templateSpecializationType(templateArgumentCountIs(2))));
909}
910
911TEST(IsIntegral, Matches) {
912 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
913 classTemplateSpecializationDecl(
914 hasAnyTemplateArgument(isIntegral()))));
915 EXPECT_TRUE(notMatches("template<typename T> struct C {}; C<int> c;",
916 classTemplateSpecializationDecl(hasAnyTemplateArgument(
917 templateArgument(isIntegral())))));
918}
919
920TEST(EqualsIntegralValue, Matches) {
921 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
922 classTemplateSpecializationDecl(
923 hasAnyTemplateArgument(equalsIntegralValue("42")))));
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<-0042> c;",
928 classTemplateSpecializationDecl(
929 hasAnyTemplateArgument(equalsIntegralValue("-34")))));
930 EXPECT_TRUE(notMatches("template<int T> struct C {}; C<42> c;",
931 classTemplateSpecializationDecl(hasAnyTemplateArgument(
932 equalsIntegralValue("0042")))));
933}
934
935TEST(Matcher, MatchesAccessSpecDecls) {
936 EXPECT_TRUE(matches("class C { public: int i; };", accessSpecDecl()));
937 EXPECT_TRUE(
938 matches("class C { public: int i; };", accessSpecDecl(isPublic())));
939 EXPECT_TRUE(
940 notMatches("class C { public: int i; };", accessSpecDecl(isProtected())));
941 EXPECT_TRUE(
942 notMatches("class C { public: int i; };", accessSpecDecl(isPrivate())));
943
944 EXPECT_TRUE(notMatches("class C { int i; };", accessSpecDecl()));
945}
946
947TEST(Matcher, MatchesFinal) {
948 EXPECT_TRUE(matches("class X final {};", cxxRecordDecl(isFinal())));
949 EXPECT_TRUE(matches("class X { virtual void f() final; };",
950 cxxMethodDecl(isFinal())));
951 EXPECT_TRUE(notMatches("class X {};", cxxRecordDecl(isFinal())));
952 EXPECT_TRUE(
953 notMatches("class X { virtual void f(); };", cxxMethodDecl(isFinal())));
954}
955
956TEST(Matcher, MatchesVirtualMethod) {
957 EXPECT_TRUE(matches("class X { virtual int f(); };",
958 cxxMethodDecl(isVirtual(), hasName("::X::f"))));
959 EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isVirtual())));
960}
961
962TEST(Matcher, MatchesVirtualAsWrittenMethod) {
963 EXPECT_TRUE(matches("class A { virtual int f(); };"
964 "class B : public A { int f(); };",
965 cxxMethodDecl(isVirtualAsWritten(), hasName("::A::f"))));
966 EXPECT_TRUE(
967 notMatches("class A { virtual int f(); };"
968 "class B : public A { int f(); };",
969 cxxMethodDecl(isVirtualAsWritten(), hasName("::B::f"))));
970}
971
972TEST(Matcher, MatchesPureMethod) {
973 EXPECT_TRUE(matches("class X { virtual int f() = 0; };",
974 cxxMethodDecl(isPure(), hasName("::X::f"))));
975 EXPECT_TRUE(notMatches("class X { int f(); };", cxxMethodDecl(isPure())));
976}
977
978TEST(Matcher, MatchesCopyAssignmentOperator) {
979 EXPECT_TRUE(matches("class X { X &operator=(X); };",
980 cxxMethodDecl(isCopyAssignmentOperator())));
981 EXPECT_TRUE(matches("class X { X &operator=(X &); };",
982 cxxMethodDecl(isCopyAssignmentOperator())));
983 EXPECT_TRUE(matches("class X { X &operator=(const X &); };",
984 cxxMethodDecl(isCopyAssignmentOperator())));
985 EXPECT_TRUE(matches("class X { X &operator=(volatile X &); };",
986 cxxMethodDecl(isCopyAssignmentOperator())));
987 EXPECT_TRUE(matches("class X { X &operator=(const volatile X &); };",
988 cxxMethodDecl(isCopyAssignmentOperator())));
989 EXPECT_TRUE(notMatches("class X { X &operator=(X &&); };",
990 cxxMethodDecl(isCopyAssignmentOperator())));
991}
992
993TEST(Matcher, MatchesMoveAssignmentOperator) {
994 EXPECT_TRUE(notMatches("class X { X &operator=(X); };",
995 cxxMethodDecl(isMoveAssignmentOperator())));
996 EXPECT_TRUE(matches("class X { X &operator=(X &&); };",
997 cxxMethodDecl(isMoveAssignmentOperator())));
998 EXPECT_TRUE(matches("class X { X &operator=(const X &&); };",
999 cxxMethodDecl(isMoveAssignmentOperator())));
1000 EXPECT_TRUE(matches("class X { X &operator=(volatile X &&); };",
1001 cxxMethodDecl(isMoveAssignmentOperator())));
1002 EXPECT_TRUE(matches("class X { X &operator=(const volatile X &&); };",
1003 cxxMethodDecl(isMoveAssignmentOperator())));
1004 EXPECT_TRUE(notMatches("class X { X &operator=(X &); };",
1005 cxxMethodDecl(isMoveAssignmentOperator())));
1006}
1007
1008TEST(Matcher, MatchesConstMethod) {
1009 EXPECT_TRUE(
1010 matches("struct A { void foo() const; };", cxxMethodDecl(isConst())));
1011 EXPECT_TRUE(
1012 notMatches("struct A { void foo(); };", cxxMethodDecl(isConst())));
1013}
1014
1015TEST(Matcher, MatchesOverridingMethod) {
1016 EXPECT_TRUE(matches("class X { virtual int f(); }; "
1017 "class Y : public X { int f(); };",
1018 cxxMethodDecl(isOverride(), hasName("::Y::f"))));
1019 EXPECT_TRUE(notMatches("class X { virtual int f(); }; "
1020 "class Y : public X { int f(); };",
1021 cxxMethodDecl(isOverride(), hasName("::X::f"))));
1022 EXPECT_TRUE(notMatches("class X { int f(); }; "
1023 "class Y : public X { int f(); };",
1024 cxxMethodDecl(isOverride())));
1025 EXPECT_TRUE(notMatches("class X { int f(); int f(int); }; ",
1026 cxxMethodDecl(isOverride())));
1027 EXPECT_TRUE(
1028 matches("template <typename Base> struct Y : Base { void f() override;};",
1029 cxxMethodDecl(isOverride(), hasName("::Y::f"))));
1030}
1031
1032TEST(Matcher, ConstructorArgument) {
1033 StatementMatcher Constructor = cxxConstructExpr(
1034 hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
1035
1036 EXPECT_TRUE(
1037 matches("class X { public: X(int); }; void x() { int y; X x(y); }",
1038 Constructor));
1039 EXPECT_TRUE(
1040 matches("class X { public: X(int); }; void x() { int y; X x = X(y); }",
1041 Constructor));
1042 EXPECT_TRUE(
1043 matches("class X { public: X(int); }; void x() { int y; X x = y; }",
1044 Constructor));
1045 EXPECT_TRUE(
1046 notMatches("class X { public: X(int); }; void x() { int z; X x(z); }",
1047 Constructor));
1048
1049 StatementMatcher WrongIndex = cxxConstructExpr(
1050 hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
1051 EXPECT_TRUE(
1052 notMatches("class X { public: X(int); }; void x() { int y; X x(y); }",
1053 WrongIndex));
1054}
1055
1056TEST(Matcher, ConstructorArgumentCount) {
1057 StatementMatcher Constructor1Arg = cxxConstructExpr(argumentCountIs(1));
1058
1059 EXPECT_TRUE(
1060 matches("class X { public: X(int); }; void x() { X x(0); }",
1061 Constructor1Arg));
1062 EXPECT_TRUE(
1063 matches("class X { public: X(int); }; void x() { X x = X(0); }",
1064 Constructor1Arg));
1065 EXPECT_TRUE(
1066 matches("class X { public: X(int); }; void x() { X x = 0; }",
1067 Constructor1Arg));
1068 EXPECT_TRUE(
1069 notMatches("class X { public: X(int, int); }; void x() { X x(0, 0); }",
1070 Constructor1Arg));
1071}
1072
1073TEST(Matcher, ConstructorListInitialization) {
1074 StatementMatcher ConstructorListInit =
1075 cxxConstructExpr(isListInitialization());
1076
1077 EXPECT_TRUE(
1078 matches("class X { public: X(int); }; void x() { X x{0}; }",
1079 ConstructorListInit));
1080 EXPECT_FALSE(
1081 matches("class X { public: X(int); }; void x() { X x(0); }",
1082 ConstructorListInit));
1083}
1084
1085TEST(ConstructorDeclaration, IsImplicit) {
1086 // This one doesn't match because the constructor is not added by the
1087 // compiler (it is not needed).
1088 EXPECT_TRUE(notMatches("class Foo { };",
1089 cxxConstructorDecl(isImplicit())));
1090 // The compiler added the implicit default constructor.
1091 EXPECT_TRUE(matches("class Foo { }; Foo* f = new Foo();",
1092 cxxConstructorDecl(isImplicit())));
1093 EXPECT_TRUE(matches("class Foo { Foo(){} };",
1094 cxxConstructorDecl(unless(isImplicit()))));
1095 // The compiler added an implicit assignment operator.
1096 EXPECT_TRUE(matches("struct A { int x; } a = {0}, b = a; void f() { a = b; }",
1097 cxxMethodDecl(isImplicit(), hasName("operator="))));
1098}
1099
1100TEST(ConstructorDeclaration, IsExplicit) {
1101 EXPECT_TRUE(matches("struct S { explicit S(int); };",
1102 cxxConstructorDecl(isExplicit())));
1103 EXPECT_TRUE(notMatches("struct S { S(int); };",
1104 cxxConstructorDecl(isExplicit())));
1105}
1106
1107TEST(ConstructorDeclaration, Kinds) {
1108 EXPECT_TRUE(matches("struct S { S(); };",
1109 cxxConstructorDecl(isDefaultConstructor())));
1110 EXPECT_TRUE(notMatches("struct S { S(); };",
1111 cxxConstructorDecl(isCopyConstructor())));
1112 EXPECT_TRUE(notMatches("struct S { S(); };",
1113 cxxConstructorDecl(isMoveConstructor())));
1114
1115 EXPECT_TRUE(notMatches("struct S { S(const S&); };",
1116 cxxConstructorDecl(isDefaultConstructor())));
1117 EXPECT_TRUE(matches("struct S { S(const S&); };",
1118 cxxConstructorDecl(isCopyConstructor())));
1119 EXPECT_TRUE(notMatches("struct S { S(const S&); };",
1120 cxxConstructorDecl(isMoveConstructor())));
1121
1122 EXPECT_TRUE(notMatches("struct S { S(S&&); };",
1123 cxxConstructorDecl(isDefaultConstructor())));
1124 EXPECT_TRUE(notMatches("struct S { S(S&&); };",
1125 cxxConstructorDecl(isCopyConstructor())));
1126 EXPECT_TRUE(matches("struct S { S(S&&); };",
1127 cxxConstructorDecl(isMoveConstructor())));
1128}
1129
1130TEST(ConstructorDeclaration, IsUserProvided) {
1131 EXPECT_TRUE(notMatches("struct S { int X = 0; };",
1132 cxxConstructorDecl(isUserProvided())));
1133 EXPECT_TRUE(notMatches("struct S { S() = default; };",
1134 cxxConstructorDecl(isUserProvided())));
1135 EXPECT_TRUE(notMatches("struct S { S() = delete; };",
1136 cxxConstructorDecl(isUserProvided())));
1137 EXPECT_TRUE(
1138 matches("struct S { S(); };", cxxConstructorDecl(isUserProvided())));
1139 EXPECT_TRUE(matches("struct S { S(); }; S::S(){}",
1140 cxxConstructorDecl(isUserProvided())));
1141}
1142
1143TEST(ConstructorDeclaration, IsDelegatingConstructor) {
1144 EXPECT_TRUE(notMatches("struct S { S(); S(int); int X; };",
1145 cxxConstructorDecl(isDelegatingConstructor())));
1146 EXPECT_TRUE(notMatches("struct S { S(){} S(int X) : X(X) {} int X; };",
1147 cxxConstructorDecl(isDelegatingConstructor())));
1148 EXPECT_TRUE(matches(
1149 "struct S { S() : S(0) {} S(int X) : X(X) {} int X; };",
1150 cxxConstructorDecl(isDelegatingConstructor(), parameterCountIs(0))));
1151 EXPECT_TRUE(matches(
1152 "struct S { S(); S(int X); int X; }; S::S(int X) : S() {}",
1153 cxxConstructorDecl(isDelegatingConstructor(), parameterCountIs(1))));
1154}
1155
1156TEST(StringLiteral, HasSize) {
1157 StatementMatcher Literal = stringLiteral(hasSize(4));
1158 EXPECT_TRUE(matches("const char *s = \"abcd\";", Literal));
1159 // wide string
1160 EXPECT_TRUE(matches("const wchar_t *s = L\"abcd\";", Literal));
1161 // with escaped characters
1162 EXPECT_TRUE(matches("const char *s = \"\x05\x06\x07\x08\";", Literal));
1163 // no matching, too small
1164 EXPECT_TRUE(notMatches("const char *s = \"ab\";", Literal));
1165}
1166
1167TEST(Matcher, HasNameSupportsNamespaces) {
1168 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1169 recordDecl(hasName("a::b::C"))));
1170 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1171 recordDecl(hasName("::a::b::C"))));
1172 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1173 recordDecl(hasName("b::C"))));
1174 EXPECT_TRUE(matches("namespace a { namespace b { class C; } }",
1175 recordDecl(hasName("C"))));
1176 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1177 recordDecl(hasName("c::b::C"))));
1178 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1179 recordDecl(hasName("a::c::C"))));
1180 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1181 recordDecl(hasName("a::b::A"))));
1182 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1183 recordDecl(hasName("::C"))));
1184 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1185 recordDecl(hasName("::b::C"))));
1186 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1187 recordDecl(hasName("z::a::b::C"))));
1188 EXPECT_TRUE(notMatches("namespace a { namespace b { class C; } }",
1189 recordDecl(hasName("a+b::C"))));
1190 EXPECT_TRUE(notMatches("namespace a { namespace b { class AC; } }",
1191 recordDecl(hasName("C"))));
1192}
1193
1194TEST(Matcher, HasNameSupportsOuterClasses) {
1195 EXPECT_TRUE(
1196 matches("class A { class B { class C; }; };",
1197 recordDecl(hasName("A::B::C"))));
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("B::C"))));
1204 EXPECT_TRUE(
1205 matches("class A { class B { class C; }; };",
1206 recordDecl(hasName("C"))));
1207 EXPECT_TRUE(
1208 notMatches("class A { class B { class C; }; };",
1209 recordDecl(hasName("c::B::C"))));
1210 EXPECT_TRUE(
1211 notMatches("class A { class B { class C; }; };",
1212 recordDecl(hasName("A::c::C"))));
1213 EXPECT_TRUE(
1214 notMatches("class A { class B { class C; }; };",
1215 recordDecl(hasName("A::B::A"))));
1216 EXPECT_TRUE(
1217 notMatches("class A { class B { class C; }; };",
1218 recordDecl(hasName("::C"))));
1219 EXPECT_TRUE(
1220 notMatches("class A { class B { class C; }; };",
1221 recordDecl(hasName("::B::C"))));
1222 EXPECT_TRUE(notMatches("class A { class B { class C; }; };",
1223 recordDecl(hasName("z::A::B::C"))));
1224 EXPECT_TRUE(
1225 notMatches("class A { class B { class C; }; };",
1226 recordDecl(hasName("A+B::C"))));
1227}
1228
1229TEST(Matcher, HasNameSupportsInlinedNamespaces) {
1230 std::string code = "namespace a { inline namespace b { class C; } }";
1231 EXPECT_TRUE(matches(code, recordDecl(hasName("a::b::C"))));
1232 EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1233 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::b::C"))));
1234 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1235}
1236
1237TEST(Matcher, HasNameSupportsAnonymousNamespaces) {
1238 std::string code = "namespace a { namespace { class C; } }";
1239 EXPECT_TRUE(
1240 matches(code, recordDecl(hasName("a::(anonymous namespace)::C"))));
1241 EXPECT_TRUE(matches(code, recordDecl(hasName("a::C"))));
1242 EXPECT_TRUE(
1243 matches(code, recordDecl(hasName("::a::(anonymous namespace)::C"))));
1244 EXPECT_TRUE(matches(code, recordDecl(hasName("::a::C"))));
1245}
1246
1247TEST(Matcher, HasNameSupportsAnonymousOuterClasses) {
1248 EXPECT_TRUE(matches("class A { class { class C; } x; };",
1249 recordDecl(hasName("A::(anonymous class)::C"))));
1250 EXPECT_TRUE(matches("class A { class { class C; } x; };",
1251 recordDecl(hasName("::A::(anonymous class)::C"))));
1252 EXPECT_FALSE(matches("class A { class { class C; } x; };",
1253 recordDecl(hasName("::A::C"))));
1254 EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1255 recordDecl(hasName("A::(anonymous struct)::C"))));
1256 EXPECT_TRUE(matches("class A { struct { class C; } x; };",
1257 recordDecl(hasName("::A::(anonymous struct)::C"))));
1258 EXPECT_FALSE(matches("class A { struct { class C; } x; };",
1259 recordDecl(hasName("::A::C"))));
1260}
1261
1262TEST(Matcher, HasNameSupportsFunctionScope) {
1263 std::string code =
1264 "namespace a { void F(int a) { struct S { int m; }; int i; } }";
1265 EXPECT_TRUE(matches(code, varDecl(hasName("i"))));
1266 EXPECT_FALSE(matches(code, varDecl(hasName("F()::i"))));
1267
1268 EXPECT_TRUE(matches(code, fieldDecl(hasName("m"))));
1269 EXPECT_TRUE(matches(code, fieldDecl(hasName("S::m"))));
1270 EXPECT_TRUE(matches(code, fieldDecl(hasName("F(int)::S::m"))));
1271 EXPECT_TRUE(matches(code, fieldDecl(hasName("a::F(int)::S::m"))));
1272 EXPECT_TRUE(matches(code, fieldDecl(hasName("::a::F(int)::S::m"))));
1273}
1274
1275TEST(Matcher, HasAnyName) {
1276 const std::string Code = "namespace a { namespace b { class C; } }";
1277
1278 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "a::b::C"))));
1279 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("a::b::C", "XX"))));
1280 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX::C", "a::b::C"))));
1281 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "C"))));
1282
1283 EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
1284 EXPECT_TRUE(
1285 matches(Code, recordDecl(hasAnyName("::C", "::b::C", "::a::b::C"))));
1286
1287 std::vector<StringRef> Names = {"::C", "::b::C", "::a::b::C"};
1288 EXPECT_TRUE(matches(Code, recordDecl(hasAnyName(Names))));
1289}
1290
1291TEST(Matcher, IsDefinition) {
1292 DeclarationMatcher DefinitionOfClassA =
1293 recordDecl(hasName("A"), isDefinition());
1294 EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
1295 EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));
1296
1297 DeclarationMatcher DefinitionOfVariableA =
1298 varDecl(hasName("a"), isDefinition());
1299 EXPECT_TRUE(matches("int a;", DefinitionOfVariableA));
1300 EXPECT_TRUE(notMatches("extern int a;", DefinitionOfVariableA));
1301
1302 DeclarationMatcher DefinitionOfMethodA =
1303 cxxMethodDecl(hasName("a"), isDefinition());
1304 EXPECT_TRUE(matches("class A { void a() {} };", DefinitionOfMethodA));
1305 EXPECT_TRUE(notMatches("class A { void a(); };", DefinitionOfMethodA));
1306}
1307
1308TEST(Matcher, HandlesNullQualTypes) {
1309 // FIXME: Add a Type matcher so we can replace uses of this
1310 // variable with Type(True())
1311 const TypeMatcher AnyType = anything();
1312
1313 // We don't really care whether this matcher succeeds; we're testing that
1314 // it completes without crashing.
1315 EXPECT_TRUE(matches(
1316 "struct A { };"
1317 "template <typename T>"
1318 "void f(T t) {"
1319 " T local_t(t /* this becomes a null QualType in the AST */);"
1320 "}"
1321 "void g() {"
1322 " f(0);"
1323 "}",
1324 expr(hasType(TypeMatcher(
1325 anyOf(
1326 TypeMatcher(hasDeclaration(anything())),
1327 pointsTo(AnyType),
1328 references(AnyType)
1329 // Other QualType matchers should go here.
1330 ))))));
1331}
1332
1333
1334TEST(StatementCountIs, FindsNoStatementsInAnEmptyCompoundStatement) {
1335 EXPECT_TRUE(matches("void f() { }",
1336 compoundStmt(statementCountIs(0))));
1337 EXPECT_TRUE(notMatches("void f() {}",
1338 compoundStmt(statementCountIs(1))));
1339}
1340
1341TEST(StatementCountIs, AppearsToMatchOnlyOneCount) {
1342 EXPECT_TRUE(matches("void f() { 1; }",
1343 compoundStmt(statementCountIs(1))));
1344 EXPECT_TRUE(notMatches("void f() { 1; }",
1345 compoundStmt(statementCountIs(0))));
1346 EXPECT_TRUE(notMatches("void f() { 1; }",
1347 compoundStmt(statementCountIs(2))));
1348}
1349
1350TEST(StatementCountIs, WorksWithMultipleStatements) {
1351 EXPECT_TRUE(matches("void f() { 1; 2; 3; }",
1352 compoundStmt(statementCountIs(3))));
1353}
1354
1355TEST(StatementCountIs, WorksWithNestedCompoundStatements) {
1356 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1357 compoundStmt(statementCountIs(1))));
1358 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1359 compoundStmt(statementCountIs(2))));
1360 EXPECT_TRUE(notMatches("void f() { { 1; } { 1; 2; 3; 4; } }",
1361 compoundStmt(statementCountIs(3))));
1362 EXPECT_TRUE(matches("void f() { { 1; } { 1; 2; 3; 4; } }",
1363 compoundStmt(statementCountIs(4))));
1364}
1365
1366TEST(Member, WorksInSimplestCase) {
1367 EXPECT_TRUE(matches("struct { int first; } s; int i(s.first);",
1368 memberExpr(member(hasName("first")))));
1369}
1370
1371TEST(Member, DoesNotMatchTheBaseExpression) {
1372 // Don't pick out the wrong part of the member expression, this should
1373 // be checking the member (name) only.
1374 EXPECT_TRUE(notMatches("struct { int i; } first; int i(first.i);",
1375 memberExpr(member(hasName("first")))));
1376}
1377
1378TEST(Member, MatchesInMemberFunctionCall) {
1379 EXPECT_TRUE(matches("void f() {"
1380 " struct { void first() {}; } s;"
1381 " s.first();"
1382 "};",
1383 memberExpr(member(hasName("first")))));
1384}
1385
1386TEST(Member, MatchesMember) {
1387 EXPECT_TRUE(matches(
1388 "struct A { int i; }; void f() { A a; a.i = 2; }",
1389 memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
1390 EXPECT_TRUE(notMatches(
1391 "struct A { float f; }; void f() { A a; a.f = 2.0f; }",
1392 memberExpr(hasDeclaration(fieldDecl(hasType(isInteger()))))));
1393}
1394
Aaron Ballman5c574342016-07-06 18:25:16 +0000[diff] [blame]1395TEST(Member, BitFields) {
1396 EXPECT_TRUE(matches("class C { int a : 2; int b; };",
1397 fieldDecl(isBitField(), hasName("a"))));
1398 EXPECT_TRUE(notMatches("class C { int a : 2; int b; };",
1399 fieldDecl(isBitField(), hasName("b"))));
1400 EXPECT_TRUE(matches("class C { int a : 2; int b : 4; };",
1401 fieldDecl(isBitField(), hasBitWidth(2), hasName("a"))));
1402}
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]1403
1404TEST(Member, UnderstandsAccess) {
1405 EXPECT_TRUE(matches(
1406 "struct A { int i; };", fieldDecl(isPublic(), hasName("i"))));
1407 EXPECT_TRUE(notMatches(
1408 "struct A { int i; };", fieldDecl(isProtected(), hasName("i"))));
1409 EXPECT_TRUE(notMatches(
1410 "struct A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
1411
1412 EXPECT_TRUE(notMatches(
1413 "class A { int i; };", fieldDecl(isPublic(), hasName("i"))));
1414 EXPECT_TRUE(notMatches(
1415 "class A { int i; };", fieldDecl(isProtected(), hasName("i"))));
1416 EXPECT_TRUE(matches(
1417 "class A { int i; };", fieldDecl(isPrivate(), hasName("i"))));
1418
1419 EXPECT_TRUE(notMatches(
1420 "class A { protected: int i; };", fieldDecl(isPublic(), hasName("i"))));
1421 EXPECT_TRUE(matches("class A { protected: int i; };",
1422 fieldDecl(isProtected(), hasName("i"))));
1423 EXPECT_TRUE(notMatches(
1424 "class A { protected: int i; };", fieldDecl(isPrivate(), hasName("i"))));
1425
1426 // Non-member decls have the AccessSpecifier AS_none and thus aren't matched.
1427 EXPECT_TRUE(notMatches("int i;", varDecl(isPublic(), hasName("i"))));
1428 EXPECT_TRUE(notMatches("int i;", varDecl(isProtected(), hasName("i"))));
1429 EXPECT_TRUE(notMatches("int i;", varDecl(isPrivate(), hasName("i"))));
1430}
1431
1432TEST(hasDynamicExceptionSpec, MatchesDynamicExceptionSpecifications) {
1433 EXPECT_TRUE(notMatches("void f();", functionDecl(hasDynamicExceptionSpec())));
1434 EXPECT_TRUE(notMatches("void g() noexcept;",
1435 functionDecl(hasDynamicExceptionSpec())));
1436 EXPECT_TRUE(notMatches("void h() noexcept(true);",
1437 functionDecl(hasDynamicExceptionSpec())));
1438 EXPECT_TRUE(notMatches("void i() noexcept(false);",
1439 functionDecl(hasDynamicExceptionSpec())));
1440 EXPECT_TRUE(
1441 matches("void j() throw();", functionDecl(hasDynamicExceptionSpec())));
1442 EXPECT_TRUE(
1443 matches("void k() throw(int);", functionDecl(hasDynamicExceptionSpec())));
1444 EXPECT_TRUE(
1445 matches("void l() throw(...);", functionDecl(hasDynamicExceptionSpec())));
Aaron Ballman230ad972016-06-07 17:34:45 +0000[diff] [blame]1446
1447 EXPECT_TRUE(notMatches("void f();", functionProtoType(hasDynamicExceptionSpec())));
1448 EXPECT_TRUE(notMatches("void g() noexcept;",
1449 functionProtoType(hasDynamicExceptionSpec())));
1450 EXPECT_TRUE(notMatches("void h() noexcept(true);",
1451 functionProtoType(hasDynamicExceptionSpec())));
1452 EXPECT_TRUE(notMatches("void i() noexcept(false);",
1453 functionProtoType(hasDynamicExceptionSpec())));
1454 EXPECT_TRUE(
1455 matches("void j() throw();", functionProtoType(hasDynamicExceptionSpec())));
1456 EXPECT_TRUE(
1457 matches("void k() throw(int);", functionProtoType(hasDynamicExceptionSpec())));
1458 EXPECT_TRUE(
1459 matches("void l() throw(...);", functionProtoType(hasDynamicExceptionSpec())));
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]1460}
1461
1462TEST(HasObjectExpression, DoesNotMatchMember) {
1463 EXPECT_TRUE(notMatches(
1464 "class X {}; struct Z { X m; }; void f(Z z) { z.m; }",
1465 memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
1466}
1467
1468TEST(HasObjectExpression, MatchesBaseOfVariable) {
1469 EXPECT_TRUE(matches(
1470 "struct X { int m; }; void f(X x) { x.m; }",
1471 memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))));
1472 EXPECT_TRUE(matches(
1473 "struct X { int m; }; void f(X* x) { x->m; }",
1474 memberExpr(hasObjectExpression(
1475 hasType(pointsTo(recordDecl(hasName("X"))))))));
1476}
1477
1478TEST(HasObjectExpression,
1479 MatchesObjectExpressionOfImplicitlyFormedMemberExpression) {
1480 EXPECT_TRUE(matches(
1481 "class X {}; struct S { X m; void f() { this->m; } };",
1482 memberExpr(hasObjectExpression(
1483 hasType(pointsTo(recordDecl(hasName("S"))))))));
1484 EXPECT_TRUE(matches(
1485 "class X {}; struct S { X m; void f() { m; } };",
1486 memberExpr(hasObjectExpression(
1487 hasType(pointsTo(recordDecl(hasName("S"))))))));
1488}
1489
1490TEST(Field, DoesNotMatchNonFieldMembers) {
1491 EXPECT_TRUE(notMatches("class X { void m(); };", fieldDecl(hasName("m"))));
1492 EXPECT_TRUE(notMatches("class X { class m {}; };", fieldDecl(hasName("m"))));
1493 EXPECT_TRUE(notMatches("class X { enum { m }; };", fieldDecl(hasName("m"))));
1494 EXPECT_TRUE(notMatches("class X { enum m {}; };", fieldDecl(hasName("m"))));
1495}
1496
1497TEST(Field, MatchesField) {
1498 EXPECT_TRUE(matches("class X { int m; };", fieldDecl(hasName("m"))));
1499}
1500
1501TEST(IsVolatileQualified, QualifiersMatch) {
1502 EXPECT_TRUE(matches("volatile int i = 42;",
1503 varDecl(hasType(isVolatileQualified()))));
1504 EXPECT_TRUE(notMatches("volatile int *i;",
1505 varDecl(hasType(isVolatileQualified()))));
1506 EXPECT_TRUE(matches("typedef volatile int v_int; v_int i = 42;",
1507 varDecl(hasType(isVolatileQualified()))));
1508}
1509
1510TEST(IsConstQualified, MatchesConstInt) {
1511 EXPECT_TRUE(matches("const int i = 42;",
1512 varDecl(hasType(isConstQualified()))));
1513}
1514
1515TEST(IsConstQualified, MatchesConstPointer) {
1516 EXPECT_TRUE(matches("int i = 42; int* const p(&i);",
1517 varDecl(hasType(isConstQualified()))));
1518}
1519
1520TEST(IsConstQualified, MatchesThroughTypedef) {
1521 EXPECT_TRUE(matches("typedef const int const_int; const_int i = 42;",
1522 varDecl(hasType(isConstQualified()))));
1523 EXPECT_TRUE(matches("typedef int* int_ptr; const int_ptr p(0);",
1524 varDecl(hasType(isConstQualified()))));
1525}
1526
1527TEST(IsConstQualified, DoesNotMatchInappropriately) {
1528 EXPECT_TRUE(notMatches("typedef int nonconst_int; nonconst_int i = 42;",
1529 varDecl(hasType(isConstQualified()))));
1530 EXPECT_TRUE(notMatches("int const* p;",
1531 varDecl(hasType(isConstQualified()))));
1532}
1533
1534TEST(DeclCount, DeclCountIsCorrect) {
1535 EXPECT_TRUE(matches("void f() {int i,j;}",
1536 declStmt(declCountIs(2))));
1537 EXPECT_TRUE(notMatches("void f() {int i,j; int k;}",
1538 declStmt(declCountIs(3))));
1539 EXPECT_TRUE(notMatches("void f() {int i,j, k, l;}",
1540 declStmt(declCountIs(3))));
1541}
1542
1543
1544TEST(EachOf, TriggersForEachMatch) {
1545 EXPECT_TRUE(matchAndVerifyResultTrue(
1546 "class A { int a; int b; };",
1547 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1548 has(fieldDecl(hasName("b")).bind("v")))),
1549 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
1550}
1551
1552TEST(EachOf, BehavesLikeAnyOfUnlessBothMatch) {
1553 EXPECT_TRUE(matchAndVerifyResultTrue(
1554 "class A { int a; int c; };",
1555 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1556 has(fieldDecl(hasName("b")).bind("v")))),
1557 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
1558 EXPECT_TRUE(matchAndVerifyResultTrue(
1559 "class A { int c; int b; };",
1560 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1561 has(fieldDecl(hasName("b")).bind("v")))),
1562 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 1)));
1563 EXPECT_TRUE(notMatches(
1564 "class A { int c; int d; };",
1565 recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
1566 has(fieldDecl(hasName("b")).bind("v"))))));
1567}
1568
1569TEST(IsTemplateInstantiation, MatchesImplicitClassTemplateInstantiation) {
1570 // Make sure that we can both match the class by name (::X) and by the type
1571 // the template was instantiated with (via a field).
1572
1573 EXPECT_TRUE(matches(
1574 "template <typename T> class X {}; class A {}; X<A> x;",
1575 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1576
1577 EXPECT_TRUE(matches(
1578 "template <typename T> class X { T t; }; class A {}; X<A> x;",
1579 cxxRecordDecl(isTemplateInstantiation(), hasDescendant(
1580 fieldDecl(hasType(recordDecl(hasName("A"))))))));
1581}
1582
1583TEST(IsTemplateInstantiation, MatchesImplicitFunctionTemplateInstantiation) {
1584 EXPECT_TRUE(matches(
1585 "template <typename T> void f(T t) {} class A {}; void g() { f(A()); }",
1586 functionDecl(hasParameter(0, hasType(recordDecl(hasName("A")))),
1587 isTemplateInstantiation())));
1588}
1589
1590TEST(IsTemplateInstantiation, MatchesExplicitClassTemplateInstantiation) {
1591 EXPECT_TRUE(matches(
1592 "template <typename T> class X { T t; }; class A {};"
1593 "template class X<A>;",
1594 cxxRecordDecl(isTemplateInstantiation(), hasDescendant(
1595 fieldDecl(hasType(recordDecl(hasName("A"))))))));
1596}
1597
1598TEST(IsTemplateInstantiation,
1599 MatchesInstantiationOfPartiallySpecializedClassTemplate) {
1600 EXPECT_TRUE(matches(
1601 "template <typename T> class X {};"
1602 "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
1603 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1604}
1605
1606TEST(IsTemplateInstantiation,
1607 MatchesInstantiationOfClassTemplateNestedInNonTemplate) {
1608 EXPECT_TRUE(matches(
1609 "class A {};"
1610 "class X {"
1611 " template <typename U> class Y { U u; };"
1612 " Y<A> y;"
1613 "};",
1614 cxxRecordDecl(hasName("::X::Y"), isTemplateInstantiation())));
1615}
1616
1617TEST(IsTemplateInstantiation, DoesNotMatchInstantiationsInsideOfInstantiation) {
1618 // FIXME: Figure out whether this makes sense. It doesn't affect the
1619 // normal use case as long as the uppermost instantiation always is marked
1620 // as template instantiation, but it might be confusing as a predicate.
1621 EXPECT_TRUE(matches(
1622 "class A {};"
1623 "template <typename T> class X {"
1624 " template <typename U> class Y { U u; };"
1625 " Y<T> y;"
1626 "}; X<A> x;",
1627 cxxRecordDecl(hasName("::X<A>::Y"), unless(isTemplateInstantiation()))));
1628}
1629
1630TEST(IsTemplateInstantiation, DoesNotMatchExplicitClassTemplateSpecialization) {
1631 EXPECT_TRUE(notMatches(
1632 "template <typename T> class X {}; class A {};"
1633 "template <> class X<A> {}; X<A> x;",
1634 cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));
1635}
1636
1637TEST(IsTemplateInstantiation, DoesNotMatchNonTemplate) {
1638 EXPECT_TRUE(notMatches(
1639 "class A {}; class Y { A a; };",
1640 cxxRecordDecl(isTemplateInstantiation())));
1641}
1642
1643TEST(IsInstantiated, MatchesInstantiation) {
1644 EXPECT_TRUE(
1645 matches("template<typename T> class A { T i; }; class Y { A<int> a; };",
1646 cxxRecordDecl(isInstantiated())));
1647}
1648
1649TEST(IsInstantiated, NotMatchesDefinition) {
1650 EXPECT_TRUE(notMatches("template<typename T> class A { T i; };",
1651 cxxRecordDecl(isInstantiated())));
1652}
1653
1654TEST(IsInTemplateInstantiation, MatchesInstantiationStmt) {
1655 EXPECT_TRUE(matches("template<typename T> struct A { A() { T i; } };"
1656 "class Y { A<int> a; }; Y y;",
1657 declStmt(isInTemplateInstantiation())));
1658}
1659
1660TEST(IsInTemplateInstantiation, NotMatchesDefinitionStmt) {
1661 EXPECT_TRUE(notMatches("template<typename T> struct A { void x() { T i; } };",
1662 declStmt(isInTemplateInstantiation())));
1663}
1664
1665TEST(IsInstantiated, MatchesFunctionInstantiation) {
1666 EXPECT_TRUE(
1667 matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
1668 functionDecl(isInstantiated())));
1669}
1670
1671TEST(IsInstantiated, NotMatchesFunctionDefinition) {
1672 EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1673 varDecl(isInstantiated())));
1674}
1675
1676TEST(IsInTemplateInstantiation, MatchesFunctionInstantiationStmt) {
1677 EXPECT_TRUE(
1678 matches("template<typename T> void A(T t) { T i; } void x() { A(0); }",
1679 declStmt(isInTemplateInstantiation())));
1680}
1681
1682TEST(IsInTemplateInstantiation, NotMatchesFunctionDefinitionStmt) {
1683 EXPECT_TRUE(notMatches("template<typename T> void A(T t) { T i; }",
1684 declStmt(isInTemplateInstantiation())));
1685}
1686
1687TEST(IsInTemplateInstantiation, Sharing) {
1688 auto Matcher = binaryOperator(unless(isInTemplateInstantiation()));
1689 // FIXME: Node sharing is an implementation detail, exposing it is ugly
1690 // and makes the matcher behave in non-obvious ways.
1691 EXPECT_TRUE(notMatches(
1692 "int j; template<typename T> void A(T t) { j += 42; } void x() { A(0); }",
1693 Matcher));
1694 EXPECT_TRUE(matches(
1695 "int j; template<typename T> void A(T t) { j += t; } void x() { A(0); }",
1696 Matcher));
1697}
1698
1699TEST(IsExplicitTemplateSpecialization,
1700 DoesNotMatchPrimaryTemplate) {
1701 EXPECT_TRUE(notMatches(
1702 "template <typename T> class X {};",
1703 cxxRecordDecl(isExplicitTemplateSpecialization())));
1704 EXPECT_TRUE(notMatches(
1705 "template <typename T> void f(T t);",
1706 functionDecl(isExplicitTemplateSpecialization())));
1707}
1708
1709TEST(IsExplicitTemplateSpecialization,
1710 DoesNotMatchExplicitTemplateInstantiations) {
1711 EXPECT_TRUE(notMatches(
1712 "template <typename T> class X {};"
1713 "template class X<int>; extern template class X<long>;",
1714 cxxRecordDecl(isExplicitTemplateSpecialization())));
1715 EXPECT_TRUE(notMatches(
1716 "template <typename T> void f(T t) {}"
1717 "template void f(int t); extern template void f(long t);",
1718 functionDecl(isExplicitTemplateSpecialization())));
1719}
1720
1721TEST(IsExplicitTemplateSpecialization,
1722 DoesNotMatchImplicitTemplateInstantiations) {
1723 EXPECT_TRUE(notMatches(
1724 "template <typename T> class X {}; X<int> x;",
1725 cxxRecordDecl(isExplicitTemplateSpecialization())));
1726 EXPECT_TRUE(notMatches(
1727 "template <typename T> void f(T t); void g() { f(10); }",
1728 functionDecl(isExplicitTemplateSpecialization())));
1729}
1730
1731TEST(IsExplicitTemplateSpecialization,
1732 MatchesExplicitTemplateSpecializations) {
1733 EXPECT_TRUE(matches(
1734 "template <typename T> class X {};"
1735 "template<> class X<int> {};",
1736 cxxRecordDecl(isExplicitTemplateSpecialization())));
1737 EXPECT_TRUE(matches(
1738 "template <typename T> void f(T t) {}"
1739 "template<> void f(int t) {}",
1740 functionDecl(isExplicitTemplateSpecialization())));
1741}
1742
1743TEST(TypeMatching, MatchesBool) {
1744 EXPECT_TRUE(matches("struct S { bool func(); };",
1745 cxxMethodDecl(returns(booleanType()))));
1746 EXPECT_TRUE(notMatches("struct S { void func(); };",
1747 cxxMethodDecl(returns(booleanType()))));
1748}
1749
1750TEST(TypeMatching, MatchesVoid) {
1751 EXPECT_TRUE(matches("struct S { void func(); };",
1752 cxxMethodDecl(returns(voidType()))));
1753}
1754
1755TEST(TypeMatching, MatchesRealFloats) {
1756 EXPECT_TRUE(matches("struct S { float func(); };",
1757 cxxMethodDecl(returns(realFloatingPointType()))));
1758 EXPECT_TRUE(notMatches("struct S { int func(); };",
1759 cxxMethodDecl(returns(realFloatingPointType()))));
1760 EXPECT_TRUE(matches("struct S { long double func(); };",
1761 cxxMethodDecl(returns(realFloatingPointType()))));
1762}
1763
1764TEST(TypeMatching, MatchesArrayTypes) {
1765 EXPECT_TRUE(matches("int a[] = {2,3};", arrayType()));
1766 EXPECT_TRUE(matches("int a[42];", arrayType()));
1767 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", arrayType()));
1768
1769 EXPECT_TRUE(notMatches("struct A {}; A a[7];",
1770 arrayType(hasElementType(builtinType()))));
1771
1772 EXPECT_TRUE(matches(
1773 "int const a[] = { 2, 3 };",
1774 qualType(arrayType(hasElementType(builtinType())))));
1775 EXPECT_TRUE(matches(
1776 "int const a[] = { 2, 3 };",
1777 qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
1778 EXPECT_TRUE(matches(
1779 "typedef const int T; T x[] = { 1, 2 };",
1780 qualType(isConstQualified(), arrayType())));
1781
1782 EXPECT_TRUE(notMatches(
1783 "int a[] = { 2, 3 };",
1784 qualType(isConstQualified(), arrayType(hasElementType(builtinType())))));
1785 EXPECT_TRUE(notMatches(
1786 "int a[] = { 2, 3 };",
1787 qualType(arrayType(hasElementType(isConstQualified(), builtinType())))));
1788 EXPECT_TRUE(notMatches(
1789 "int const a[] = { 2, 3 };",
1790 qualType(arrayType(hasElementType(builtinType())),
1791 unless(isConstQualified()))));
1792
1793 EXPECT_TRUE(matches("int a[2];",
1794 constantArrayType(hasElementType(builtinType()))));
1795 EXPECT_TRUE(matches("const int a = 0;", qualType(isInteger())));
1796}
1797
1798TEST(TypeMatching, DecayedType) {
1799 EXPECT_TRUE(matches("void f(int i[]);", valueDecl(hasType(decayedType(hasDecayedType(pointerType()))))));
1800 EXPECT_TRUE(notMatches("int i[7];", decayedType()));
1801}
1802
1803TEST(TypeMatching, MatchesComplexTypes) {
1804 EXPECT_TRUE(matches("_Complex float f;", complexType()));
1805 EXPECT_TRUE(matches(
1806 "_Complex float f;",
1807 complexType(hasElementType(builtinType()))));
1808 EXPECT_TRUE(notMatches(
1809 "_Complex float f;",
1810 complexType(hasElementType(isInteger()))));
1811}
1812
1813TEST(NS, Anonymous) {
1814 EXPECT_TRUE(notMatches("namespace N {}", namespaceDecl(isAnonymous())));
1815 EXPECT_TRUE(matches("namespace {}", namespaceDecl(isAnonymous())));
1816}
1817
1818TEST(EqualsBoundNodeMatcher, QualType) {
1819 EXPECT_TRUE(matches(
1820 "int i = 1;", varDecl(hasType(qualType().bind("type")),
1821 hasInitializer(ignoringParenImpCasts(
1822 hasType(qualType(equalsBoundNode("type"))))))));
1823 EXPECT_TRUE(notMatches("int i = 1.f;",
1824 varDecl(hasType(qualType().bind("type")),
1825 hasInitializer(ignoringParenImpCasts(hasType(
1826 qualType(equalsBoundNode("type"))))))));
1827}
1828
1829TEST(EqualsBoundNodeMatcher, NonMatchingTypes) {
1830 EXPECT_TRUE(notMatches(
1831 "int i = 1;", varDecl(namedDecl(hasName("i")).bind("name"),
1832 hasInitializer(ignoringParenImpCasts(
1833 hasType(qualType(equalsBoundNode("type"))))))));
1834}
1835
1836TEST(EqualsBoundNodeMatcher, Stmt) {
1837 EXPECT_TRUE(
1838 matches("void f() { if(true) {} }",
1839 stmt(allOf(ifStmt().bind("if"),
1840 hasParent(stmt(has(stmt(equalsBoundNode("if")))))))));
1841
1842 EXPECT_TRUE(notMatches(
1843 "void f() { if(true) { if (true) {} } }",
1844 stmt(allOf(ifStmt().bind("if"), has(stmt(equalsBoundNode("if")))))));
1845}
1846
1847TEST(EqualsBoundNodeMatcher, Decl) {
1848 EXPECT_TRUE(matches(
1849 "class X { class Y {}; };",
1850 decl(allOf(recordDecl(hasName("::X::Y")).bind("record"),
1851 hasParent(decl(has(decl(equalsBoundNode("record")))))))));
1852
1853 EXPECT_TRUE(notMatches("class X { class Y {}; };",
1854 decl(allOf(recordDecl(hasName("::X")).bind("record"),
1855 has(decl(equalsBoundNode("record")))))));
1856}
1857
1858TEST(EqualsBoundNodeMatcher, Type) {
1859 EXPECT_TRUE(matches(
1860 "class X { int a; int b; };",
1861 recordDecl(
1862 has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
1863 has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
1864
1865 EXPECT_TRUE(notMatches(
1866 "class X { int a; double b; };",
1867 recordDecl(
1868 has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
1869 has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))));
1870}
1871
1872TEST(EqualsBoundNodeMatcher, UsingForEachDescendant) {
1873 EXPECT_TRUE(matchAndVerifyResultTrue(
1874 "int f() {"
1875 " if (1) {"
1876 " int i = 9;"
1877 " }"
1878 " int j = 10;"
1879 " {"
1880 " float k = 9.0;"
1881 " }"
1882 " return 0;"
1883 "}",
1884 // Look for variable declarations within functions whose type is the same
1885 // as the function return type.
1886 functionDecl(returns(qualType().bind("type")),
1887 forEachDescendant(varDecl(hasType(
1888 qualType(equalsBoundNode("type")))).bind("decl"))),
1889 // Only i and j should match, not k.
1890 llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("decl", 2)));
1891}
1892
1893TEST(EqualsBoundNodeMatcher, FiltersMatchedCombinations) {
1894 EXPECT_TRUE(matchAndVerifyResultTrue(
1895 "void f() {"
1896 " int x;"
1897 " double d;"
1898 " x = d + x - d + x;"
1899 "}",
1900 functionDecl(
1901 hasName("f"), forEachDescendant(varDecl().bind("d")),
1902 forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d")))))),
1903 llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("d", 5)));
1904}
1905
1906TEST(EqualsBoundNodeMatcher, UnlessDescendantsOfAncestorsMatch) {
1907 EXPECT_TRUE(matchAndVerifyResultTrue(
1908 "struct StringRef { int size() const; const char* data() const; };"
1909 "void f(StringRef v) {"
1910 " v.data();"
1911 "}",
1912 cxxMemberCallExpr(
1913 callee(cxxMethodDecl(hasName("data"))),
1914 on(declRefExpr(to(
1915 varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
1916 unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
1917 callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
1918 on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
1919 .bind("data"),
1920 llvm::make_unique<VerifyIdIsBoundTo<Expr>>("data", 1)));
1921
1922 EXPECT_FALSE(matches(
1923 "struct StringRef { int size() const; const char* data() const; };"
1924 "void f(StringRef v) {"
1925 " v.data();"
1926 " v.size();"
1927 "}",
1928 cxxMemberCallExpr(
1929 callee(cxxMethodDecl(hasName("data"))),
1930 on(declRefExpr(to(
1931 varDecl(hasType(recordDecl(hasName("StringRef")))).bind("var")))),
1932 unless(hasAncestor(stmt(hasDescendant(cxxMemberCallExpr(
1933 callee(cxxMethodDecl(anyOf(hasName("size"), hasName("length")))),
1934 on(declRefExpr(to(varDecl(equalsBoundNode("var")))))))))))
1935 .bind("data")));
1936}
1937
1938TEST(NullPointerConstants, Basic) {
1939 EXPECT_TRUE(matches("#define NULL ((void *)0)\n"
1940 "void *v1 = NULL;", expr(nullPointerConstant())));
1941 EXPECT_TRUE(matches("void *v2 = nullptr;", expr(nullPointerConstant())));
1942 EXPECT_TRUE(matches("void *v3 = __null;", expr(nullPointerConstant())));
1943 EXPECT_TRUE(matches("char *cp = (char *)0;", expr(nullPointerConstant())));
1944 EXPECT_TRUE(matches("int *ip = 0;", expr(nullPointerConstant())));
1945 EXPECT_TRUE(notMatches("int i = 0;", expr(nullPointerConstant())));
1946}
1947
Aaron Ballmana086b9f2016-08-17 13:10:42 +0000[diff] [blame]1948TEST(HasExternalFormalLinkage, Basic) {
1949 EXPECT_TRUE(matches("int a = 0;", namedDecl(hasExternalFormalLinkage())));
1950 EXPECT_TRUE(
1951 notMatches("static int a = 0;", namedDecl(hasExternalFormalLinkage())));
1952 EXPECT_TRUE(notMatches("static void f(void) { int a = 0; }",
1953 namedDecl(hasExternalFormalLinkage())));
1954 EXPECT_TRUE(matches("void f(void) { int a = 0; }",
1955 namedDecl(hasExternalFormalLinkage())));
1956
1957 // Despite having internal semantic linkage, the anonymous namespace member
1958 // has external linkage because the member has a unique name in all
1959 // translation units.
1960 EXPECT_TRUE(matches("namespace { int a = 0; }",
1961 namedDecl(hasExternalFormalLinkage())));
1962}
1963
Piotr Padlewskic6e05022016-05-17 19:22:57 +0000[diff] [blame]1964} // namespace ast_matchers
1965} // namespace clang