1 //= unittests/ASTMatchers/ASTMatchersTraversalTest.cpp - matchers 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
19 namespace clang {
20 namespace ast_matchers {
21
TEST(DeclarationMatcher,hasMethod)22 TEST(DeclarationMatcher, hasMethod) {
23 EXPECT_TRUE(matches("class A { void func(); };",
24 cxxRecordDecl(hasMethod(hasName("func")))));
25 EXPECT_TRUE(notMatches("class A { void func(); };",
26 cxxRecordDecl(hasMethod(isPublic()))));
27 }
28
TEST(DeclarationMatcher,ClassDerivedFromDependentTemplateSpecialization)29 TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
30 EXPECT_TRUE(matches(
31 "template <typename T> struct A {"
32 " template <typename T2> struct F {};"
33 "};"
34 "template <typename T> struct B : A<T>::template F<T> {};"
35 "B<int> b;",
36 cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
37 }
38
TEST(DeclarationMatcher,hasDeclContext)39 TEST(DeclarationMatcher, hasDeclContext) {
40 EXPECT_TRUE(matches(
41 "namespace N {"
42 " namespace M {"
43 " class D {};"
44 " }"
45 "}",
46 recordDecl(hasDeclContext(namespaceDecl(hasName("M"))))));
47 EXPECT_TRUE(notMatches(
48 "namespace N {"
49 " namespace M {"
50 " class D {};"
51 " }"
52 "}",
53 recordDecl(hasDeclContext(namespaceDecl(hasName("N"))))));
54
55 EXPECT_TRUE(matches("namespace {"
56 " namespace M {"
57 " class D {};"
58 " }"
59 "}",
60 recordDecl(hasDeclContext(namespaceDecl(
61 hasName("M"), hasDeclContext(namespaceDecl()))))));
62
63 EXPECT_TRUE(matches("class D{};", decl(hasDeclContext(decl()))));
64 }
65
TEST(HasDescendant,MatchesDescendantTypes)66 TEST(HasDescendant, MatchesDescendantTypes) {
67 EXPECT_TRUE(matches("void f() { int i = 3; }",
68 decl(hasDescendant(loc(builtinType())))));
69 EXPECT_TRUE(matches("void f() { int i = 3; }",
70 stmt(hasDescendant(builtinType()))));
71
72 EXPECT_TRUE(matches("void f() { int i = 3; }",
73 stmt(hasDescendant(loc(builtinType())))));
74 EXPECT_TRUE(matches("void f() { int i = 3; }",
75 stmt(hasDescendant(qualType(builtinType())))));
76
77 EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
78 stmt(hasDescendant(isInteger()))));
79
80 EXPECT_TRUE(matchAndVerifyResultTrue(
81 "void f() { int a; float c; int d; int e; }",
82 functionDecl(forEachDescendant(
83 varDecl(hasDescendant(isInteger())).bind("x"))),
84 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 3)));
85 }
86
TEST(HasDescendant,MatchesDescendantsOfTypes)87 TEST(HasDescendant, MatchesDescendantsOfTypes) {
88 EXPECT_TRUE(matches("void f() { int*** i; }",
89 qualType(hasDescendant(builtinType()))));
90 EXPECT_TRUE(matches("void f() { int*** i; }",
91 qualType(hasDescendant(
92 pointerType(pointee(builtinType()))))));
93 EXPECT_TRUE(matches("void f() { int*** i; }",
94 typeLoc(hasDescendant(loc(builtinType())))));
95
96 EXPECT_TRUE(matchAndVerifyResultTrue(
97 "void f() { int*** i; }",
98 qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
99 llvm::make_unique<VerifyIdIsBoundTo<Type>>("x", 2)));
100 }
101
102
TEST(Has,MatchesChildrenOfTypes)103 TEST(Has, MatchesChildrenOfTypes) {
104 EXPECT_TRUE(matches("int i;",
105 varDecl(hasName("i"), has(isInteger()))));
106 EXPECT_TRUE(notMatches("int** i;",
107 varDecl(hasName("i"), has(isInteger()))));
108 EXPECT_TRUE(matchAndVerifyResultTrue(
109 "int (*f)(float, int);",
110 qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
111 llvm::make_unique<VerifyIdIsBoundTo<QualType>>("x", 2)));
112 }
113
TEST(Has,MatchesChildTypes)114 TEST(Has, MatchesChildTypes) {
115 EXPECT_TRUE(matches(
116 "int* i;",
117 varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
118 EXPECT_TRUE(notMatches(
119 "int* i;",
120 varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
121 }
122
TEST(StatementMatcher,Has)123 TEST(StatementMatcher, Has) {
124 StatementMatcher HasVariableI =
125 expr(hasType(pointsTo(recordDecl(hasName("X")))),
126 has(ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("i")))))));
127
128 EXPECT_TRUE(matches(
129 "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
130 EXPECT_TRUE(notMatches(
131 "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
132 }
133
TEST(StatementMatcher,HasDescendant)134 TEST(StatementMatcher, HasDescendant) {
135 StatementMatcher HasDescendantVariableI =
136 expr(hasType(pointsTo(recordDecl(hasName("X")))),
137 hasDescendant(declRefExpr(to(varDecl(hasName("i"))))));
138
139 EXPECT_TRUE(matches(
140 "class X; X *x(bool); bool b(int); void c() { int i; x(b(i)); }",
141 HasDescendantVariableI));
142 EXPECT_TRUE(notMatches(
143 "class X; X *x(bool); bool b(int); void c() { int i; x(b(42)); }",
144 HasDescendantVariableI));
145 }
146
TEST(TypeMatcher,MatchesClassType)147 TEST(TypeMatcher, MatchesClassType) {
148 TypeMatcher TypeA = hasDeclaration(recordDecl(hasName("A")));
149
150 EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
151 EXPECT_TRUE(notMatches("class A {};", TypeA));
152
153 TypeMatcher TypeDerivedFromA =
154 hasDeclaration(cxxRecordDecl(isDerivedFrom("A")));
155
156 EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
157 TypeDerivedFromA));
158 EXPECT_TRUE(notMatches("class A {};", TypeA));
159
160 TypeMatcher TypeAHasClassB = hasDeclaration(
161 recordDecl(hasName("A"), has(recordDecl(hasName("B")))));
162
163 EXPECT_TRUE(
164 matches("class A { public: A *a; class B {}; };", TypeAHasClassB));
165
166 EXPECT_TRUE(matchesC("struct S {}; void f(void) { struct S s; }",
167 varDecl(hasType(namedDecl(hasName("S"))))));
168 }
169
TEST(TypeMatcher,MatchesDeclTypes)170 TEST(TypeMatcher, MatchesDeclTypes) {
171 // TypedefType -> TypedefNameDecl
172 EXPECT_TRUE(matches("typedef int I; void f(I i);",
173 parmVarDecl(hasType(namedDecl(hasName("I"))))));
174 // ObjCObjectPointerType
175 EXPECT_TRUE(matchesObjC("@interface Foo @end void f(Foo *f);",
176 parmVarDecl(hasType(objcObjectPointerType()))));
177 // ObjCObjectPointerType -> ObjCInterfaceType -> ObjCInterfaceDecl
178 EXPECT_TRUE(matchesObjC(
179 "@interface Foo @end void f(Foo *f);",
180 parmVarDecl(hasType(pointsTo(objcInterfaceDecl(hasName("Foo")))))));
181 // TemplateTypeParmType
182 EXPECT_TRUE(matches("template <typename T> void f(T t);",
183 parmVarDecl(hasType(templateTypeParmType()))));
184 // TemplateTypeParmType -> TemplateTypeParmDecl
185 EXPECT_TRUE(matches("template <typename T> void f(T t);",
186 parmVarDecl(hasType(namedDecl(hasName("T"))))));
187 // InjectedClassNameType
188 EXPECT_TRUE(matches("template <typename T> struct S {"
189 " void f(S s);"
190 "};",
191 parmVarDecl(hasType(injectedClassNameType()))));
192 EXPECT_TRUE(notMatches("template <typename T> struct S {"
193 " void g(S<T> s);"
194 "};",
195 parmVarDecl(hasType(injectedClassNameType()))));
196 // InjectedClassNameType -> CXXRecordDecl
197 EXPECT_TRUE(matches("template <typename T> struct S {"
198 " void f(S s);"
199 "};",
200 parmVarDecl(hasType(namedDecl(hasName("S"))))));
201
202 static const char Using[] = "template <typename T>"
203 "struct Base {"
204 " typedef T Foo;"
205 "};"
206 ""
207 "template <typename T>"
208 "struct S : private Base<T> {"
209 " using typename Base<T>::Foo;"
210 " void f(Foo);"
211 "};";
212 // UnresolvedUsingTypenameDecl
213 EXPECT_TRUE(matches(Using, unresolvedUsingTypenameDecl(hasName("Foo"))));
214 // UnresolvedUsingTypenameType -> UnresolvedUsingTypenameDecl
215 EXPECT_TRUE(matches(Using, parmVarDecl(hasType(namedDecl(hasName("Foo"))))));
216 }
217
TEST(HasDeclaration,HasDeclarationOfEnumType)218 TEST(HasDeclaration, HasDeclarationOfEnumType) {
219 EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
220 expr(hasType(pointsTo(
221 qualType(hasDeclaration(enumDecl(hasName("X")))))))));
222 }
223
TEST(HasDeclaration,HasGetDeclTraitTest)224 TEST(HasDeclaration, HasGetDeclTraitTest) {
225 EXPECT_TRUE(internal::has_getDecl<TypedefType>::value);
226 EXPECT_TRUE(internal::has_getDecl<RecordType>::value);
227 EXPECT_FALSE(internal::has_getDecl<TemplateSpecializationType>::value);
228 }
229
TEST(HasDeclaration,HasDeclarationOfTypeWithDecl)230 TEST(HasDeclaration, HasDeclarationOfTypeWithDecl) {
231 EXPECT_TRUE(matches("typedef int X; X a;",
232 varDecl(hasName("a"),
233 hasType(typedefType(hasDeclaration(decl()))))));
234
235 // FIXME: Add tests for other types with getDecl() (e.g. RecordType)
236 }
237
TEST(HasDeclaration,HasDeclarationOfTemplateSpecializationType)238 TEST(HasDeclaration, HasDeclarationOfTemplateSpecializationType) {
239 EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
240 varDecl(hasType(templateSpecializationType(
241 hasDeclaration(namedDecl(hasName("A"))))))));
242 }
243
TEST(HasType,TakesQualTypeMatcherAndMatchesExpr)244 TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
245 TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
246 EXPECT_TRUE(
247 matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
248 EXPECT_TRUE(
249 notMatches("class X {}; void y(X *x) { x; }",
250 expr(hasType(ClassX))));
251 EXPECT_TRUE(
252 matches("class X {}; void y(X *x) { x; }",
253 expr(hasType(pointsTo(ClassX)))));
254 }
255
TEST(HasType,TakesQualTypeMatcherAndMatchesValueDecl)256 TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
257 TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
258 EXPECT_TRUE(
259 matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
260 EXPECT_TRUE(
261 notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
262 EXPECT_TRUE(
263 matches("class X {}; void y() { X *x; }",
264 varDecl(hasType(pointsTo(ClassX)))));
265 }
266
TEST(HasType,TakesDeclMatcherAndMatchesExpr)267 TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
268 DeclarationMatcher ClassX = recordDecl(hasName("X"));
269 EXPECT_TRUE(
270 matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
271 EXPECT_TRUE(
272 notMatches("class X {}; void y(X *x) { x; }",
273 expr(hasType(ClassX))));
274 }
275
TEST(HasType,TakesDeclMatcherAndMatchesValueDecl)276 TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
277 DeclarationMatcher ClassX = recordDecl(hasName("X"));
278 EXPECT_TRUE(
279 matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
280 EXPECT_TRUE(
281 notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
282 }
283
TEST(HasType,MatchesTypedefDecl)284 TEST(HasType, MatchesTypedefDecl) {
285 EXPECT_TRUE(matches("typedef int X;", typedefDecl(hasType(asString("int")))));
286 EXPECT_TRUE(matches("typedef const int T;",
287 typedefDecl(hasType(asString("const int")))));
288 EXPECT_TRUE(notMatches("typedef const int T;",
289 typedefDecl(hasType(asString("int")))));
290 EXPECT_TRUE(matches("typedef int foo; typedef foo bar;",
291 typedefDecl(hasType(asString("foo")), hasName("bar"))));
292 }
293
TEST(HasType,MatchesTypedefNameDecl)294 TEST(HasType, MatchesTypedefNameDecl) {
295 EXPECT_TRUE(matches("using X = int;", typedefNameDecl(hasType(asString("int")))));
296 EXPECT_TRUE(matches("using T = const int;",
297 typedefNameDecl(hasType(asString("const int")))));
298 EXPECT_TRUE(notMatches("using T = const int;",
299 typedefNameDecl(hasType(asString("int")))));
300 EXPECT_TRUE(matches("using foo = int; using bar = foo;",
301 typedefNameDecl(hasType(asString("foo")), hasName("bar"))));
302 }
303
TEST(HasTypeLoc,MatchesDeclaratorDecls)304 TEST(HasTypeLoc, MatchesDeclaratorDecls) {
305 EXPECT_TRUE(matches("int x;",
306 varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
307
308 // Make sure we don't crash on implicit constructors.
309 EXPECT_TRUE(notMatches("class X {}; X x;",
310 declaratorDecl(hasTypeLoc(loc(asString("int"))))));
311 }
312
313
TEST(Callee,MatchesDeclarations)314 TEST(Callee, MatchesDeclarations) {
315 StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x"))));
316
317 EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
318 EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
319
320 CallMethodX = callExpr(callee(cxxConversionDecl()));
321 EXPECT_TRUE(
322 matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
323 EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
324 CallMethodX));
325 }
326
TEST(Callee,MatchesMemberExpressions)327 TEST(Callee, MatchesMemberExpressions) {
328 EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
329 callExpr(callee(memberExpr()))));
330 EXPECT_TRUE(
331 notMatches("class Y { void x() { this->x(); } };", callExpr(callee(callExpr()))));
332 }
333
TEST(Matcher,Argument)334 TEST(Matcher, Argument) {
335 StatementMatcher CallArgumentY = callExpr(
336 hasArgument(0, declRefExpr(to(varDecl(hasName("y"))))));
337
338 EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
339 EXPECT_TRUE(
340 matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
341 EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
342
343 StatementMatcher WrongIndex = callExpr(
344 hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
345 EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
346 }
347
TEST(Matcher,AnyArgument)348 TEST(Matcher, AnyArgument) {
349 StatementMatcher CallArgumentY = callExpr(
350 hasAnyArgument(
351 ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("y")))))));
352 EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
353 EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
354 EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
355
356 StatementMatcher ImplicitCastedArgument = callExpr(
357 hasAnyArgument(implicitCastExpr()));
358 EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
359 }
360
TEST(ForEachArgumentWithParam,ReportsNoFalsePositives)361 TEST(ForEachArgumentWithParam, ReportsNoFalsePositives) {
362 StatementMatcher ArgumentY =
363 declRefExpr(to(varDecl(hasName("y")))).bind("arg");
364 DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
365 StatementMatcher CallExpr =
366 callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
367
368 // IntParam does not match.
369 EXPECT_TRUE(notMatches("void f(int* i) { int* y; f(y); }", CallExpr));
370 // ArgumentY does not match.
371 EXPECT_TRUE(notMatches("void f(int i) { int x; f(x); }", CallExpr));
372 }
373
TEST(ForEachArgumentWithParam,MatchesCXXMemberCallExpr)374 TEST(ForEachArgumentWithParam, MatchesCXXMemberCallExpr) {
375 StatementMatcher ArgumentY =
376 declRefExpr(to(varDecl(hasName("y")))).bind("arg");
377 DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
378 StatementMatcher CallExpr =
379 callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
380 EXPECT_TRUE(matchAndVerifyResultTrue(
381 "struct S {"
382 " const S& operator[](int i) { return *this; }"
383 "};"
384 "void f(S S1) {"
385 " int y = 1;"
386 " S1[y];"
387 "}",
388 CallExpr, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
389
390 StatementMatcher CallExpr2 =
391 callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
392 EXPECT_TRUE(matchAndVerifyResultTrue(
393 "struct S {"
394 " static void g(int i);"
395 "};"
396 "void f() {"
397 " int y = 1;"
398 " S::g(y);"
399 "}",
400 CallExpr2, llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
401 }
402
TEST(ForEachArgumentWithParam,MatchesCallExpr)403 TEST(ForEachArgumentWithParam, MatchesCallExpr) {
404 StatementMatcher ArgumentY =
405 declRefExpr(to(varDecl(hasName("y")))).bind("arg");
406 DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
407 StatementMatcher CallExpr =
408 callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
409
410 EXPECT_TRUE(
411 matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
412 llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>(
413 "param")));
414 EXPECT_TRUE(
415 matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
416 llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>(
417 "arg")));
418
419 EXPECT_TRUE(matchAndVerifyResultTrue(
420 "void f(int i, int j) { int y; f(y, y); }", CallExpr,
421 llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 2)));
422 EXPECT_TRUE(matchAndVerifyResultTrue(
423 "void f(int i, int j) { int y; f(y, y); }", CallExpr,
424 llvm::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
425 }
426
TEST(ForEachArgumentWithParam,MatchesConstructExpr)427 TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
428 StatementMatcher ArgumentY =
429 declRefExpr(to(varDecl(hasName("y")))).bind("arg");
430 DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
431 StatementMatcher ConstructExpr =
432 cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam));
433
434 EXPECT_TRUE(matchAndVerifyResultTrue(
435 "struct C {"
436 " C(int i) {}"
437 "};"
438 "int y = 0;"
439 "C Obj(y);",
440 ConstructExpr,
441 llvm::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param")));
442 }
443
TEST(ForEachArgumentWithParam,HandlesBoundNodesForNonMatches)444 TEST(ForEachArgumentWithParam, HandlesBoundNodesForNonMatches) {
445 EXPECT_TRUE(matchAndVerifyResultTrue(
446 "void g(int i, int j) {"
447 " int a;"
448 " int b;"
449 " int c;"
450 " g(a, 0);"
451 " g(a, b);"
452 " g(0, b);"
453 "}",
454 functionDecl(
455 forEachDescendant(varDecl().bind("v")),
456 forEachDescendant(callExpr(forEachArgumentWithParam(
457 declRefExpr(to(decl(equalsBoundNode("v")))), parmVarDecl())))),
458 llvm::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
459 }
460
TEST(QualType,hasCanonicalType)461 TEST(QualType, hasCanonicalType) {
462 EXPECT_TRUE(notMatches("typedef int &int_ref;"
463 "int a;"
464 "int_ref b = a;",
465 varDecl(hasType(qualType(referenceType())))));
466 EXPECT_TRUE(
467 matches("typedef int &int_ref;"
468 "int a;"
469 "int_ref b = a;",
470 varDecl(hasType(qualType(hasCanonicalType(referenceType()))))));
471 }
472
TEST(HasParameter,CallsInnerMatcher)473 TEST(HasParameter, CallsInnerMatcher) {
474 EXPECT_TRUE(matches("class X { void x(int) {} };",
475 cxxMethodDecl(hasParameter(0, varDecl()))));
476 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
477 cxxMethodDecl(hasParameter(0, hasName("x")))));
478 }
479
TEST(HasParameter,DoesNotMatchIfIndexOutOfBounds)480 TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
481 EXPECT_TRUE(notMatches("class X { void x(int) {} };",
482 cxxMethodDecl(hasParameter(42, varDecl()))));
483 }
484
TEST(HasType,MatchesParameterVariableTypesStrictly)485 TEST(HasType, MatchesParameterVariableTypesStrictly) {
486 EXPECT_TRUE(matches(
487 "class X { void x(X x) {} };",
488 cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
489 EXPECT_TRUE(notMatches(
490 "class X { void x(const X &x) {} };",
491 cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
492 EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
493 cxxMethodDecl(hasParameter(
494 0, hasType(pointsTo(recordDecl(hasName("X"))))))));
495 EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
496 cxxMethodDecl(hasParameter(
497 0, hasType(references(recordDecl(hasName("X"))))))));
498 }
499
TEST(HasAnyParameter,MatchesIndependentlyOfPosition)500 TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
501 EXPECT_TRUE(matches(
502 "class Y {}; class X { void x(X x, Y y) {} };",
503 cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
504 EXPECT_TRUE(matches(
505 "class Y {}; class X { void x(Y y, X x) {} };",
506 cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
507 }
508
TEST(Returns,MatchesReturnTypes)509 TEST(Returns, MatchesReturnTypes) {
510 EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
511 functionDecl(returns(asString("int")))));
512 EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
513 functionDecl(returns(asString("float")))));
514 EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
515 functionDecl(returns(hasDeclaration(
516 recordDecl(hasName("Y")))))));
517 }
518
TEST(HasAnyParameter,DoesntMatchIfInnerMatcherDoesntMatch)519 TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
520 EXPECT_TRUE(notMatches(
521 "class Y {}; class X { void x(int) {} };",
522 cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
523 }
524
TEST(HasAnyParameter,DoesNotMatchThisPointer)525 TEST(HasAnyParameter, DoesNotMatchThisPointer) {
526 EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
527 cxxMethodDecl(hasAnyParameter(
528 hasType(pointsTo(recordDecl(hasName("X"))))))));
529 }
530
TEST(HasName,MatchesParameterVariableDeclarations)531 TEST(HasName, MatchesParameterVariableDeclarations) {
532 EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
533 cxxMethodDecl(hasAnyParameter(hasName("x")))));
534 EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
535 cxxMethodDecl(hasAnyParameter(hasName("x")))));
536 }
537
TEST(Matcher,MatchesTypeTemplateArgument)538 TEST(Matcher, MatchesTypeTemplateArgument) {
539 EXPECT_TRUE(matches(
540 "template<typename T> struct B {};"
541 "B<int> b;",
542 classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
543 asString("int"))))));
544 }
545
TEST(Matcher,MatchesDeclarationReferenceTemplateArgument)546 TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
547 EXPECT_TRUE(matches(
548 "struct B { int next; };"
549 "template<int(B::*next_ptr)> struct A {};"
550 "A<&B::next> a;",
551 classTemplateSpecializationDecl(hasAnyTemplateArgument(
552 refersToDeclaration(fieldDecl(hasName("next")))))));
553
554 EXPECT_TRUE(notMatches(
555 "template <typename T> struct A {};"
556 "A<int> a;",
557 classTemplateSpecializationDecl(hasAnyTemplateArgument(
558 refersToDeclaration(decl())))));
559
560 EXPECT_TRUE(matches(
561 "struct B { int next; };"
562 "template<int(B::*next_ptr)> struct A {};"
563 "A<&B::next> a;",
564 templateSpecializationType(hasAnyTemplateArgument(isExpr(
565 hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))));
566
567 EXPECT_TRUE(notMatches(
568 "template <typename T> struct A {};"
569 "A<int> a;",
570 templateSpecializationType(hasAnyTemplateArgument(
571 refersToDeclaration(decl())))));
572 }
573
574
TEST(Matcher,MatchesSpecificArgument)575 TEST(Matcher, MatchesSpecificArgument) {
576 EXPECT_TRUE(matches(
577 "template<typename T, typename U> class A {};"
578 "A<bool, int> a;",
579 classTemplateSpecializationDecl(hasTemplateArgument(
580 1, refersToType(asString("int"))))));
581 EXPECT_TRUE(notMatches(
582 "template<typename T, typename U> class A {};"
583 "A<int, bool> a;",
584 classTemplateSpecializationDecl(hasTemplateArgument(
585 1, refersToType(asString("int"))))));
586
587 EXPECT_TRUE(matches(
588 "template<typename T, typename U> class A {};"
589 "A<bool, int> a;",
590 templateSpecializationType(hasTemplateArgument(
591 1, refersToType(asString("int"))))));
592 EXPECT_TRUE(notMatches(
593 "template<typename T, typename U> class A {};"
594 "A<int, bool> a;",
595 templateSpecializationType(hasTemplateArgument(
596 1, refersToType(asString("int"))))));
597 }
598
TEST(TemplateArgument,Matches)599 TEST(TemplateArgument, Matches) {
600 EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
601 classTemplateSpecializationDecl(
602 hasAnyTemplateArgument(templateArgument()))));
603 EXPECT_TRUE(matches(
604 "template<typename T> struct C {}; C<int> c;",
605 templateSpecializationType(hasAnyTemplateArgument(templateArgument()))));
606 }
607
TEST(RefersToIntegralType,Matches)608 TEST(RefersToIntegralType, Matches) {
609 EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
610 classTemplateSpecializationDecl(
611 hasAnyTemplateArgument(refersToIntegralType(
612 asString("int"))))));
613 EXPECT_TRUE(notMatches("template<unsigned T> struct C {}; C<42> c;",
614 classTemplateSpecializationDecl(hasAnyTemplateArgument(
615 refersToIntegralType(asString("int"))))));
616 }
617
TEST(ConstructorDeclaration,SimpleCase)618 TEST(ConstructorDeclaration, SimpleCase) {
619 EXPECT_TRUE(matches("class Foo { Foo(int i); };",
620 cxxConstructorDecl(ofClass(hasName("Foo")))));
621 EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
622 cxxConstructorDecl(ofClass(hasName("Bar")))));
623 }
624
TEST(DestructorDeclaration,MatchesVirtualDestructor)625 TEST(DestructorDeclaration, MatchesVirtualDestructor) {
626 EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
627 cxxDestructorDecl(ofClass(hasName("Foo")))));
628 }
629
TEST(DestructorDeclaration,DoesNotMatchImplicitDestructor)630 TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {
631 EXPECT_TRUE(notMatches("class Foo {};",
632 cxxDestructorDecl(ofClass(hasName("Foo")))));
633 }
634
TEST(HasAnyConstructorInitializer,SimpleCase)635 TEST(HasAnyConstructorInitializer, SimpleCase) {
636 EXPECT_TRUE(
637 notMatches("class Foo { Foo() { } };",
638 cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
639 EXPECT_TRUE(
640 matches("class Foo {"
641 " Foo() : foo_() { }"
642 " int foo_;"
643 "};",
644 cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
645 }
646
TEST(HasAnyConstructorInitializer,ForField)647 TEST(HasAnyConstructorInitializer, ForField) {
648 static const char Code[] =
649 "class Baz { };"
650 "class Foo {"
651 " Foo() : foo_() { }"
652 " Baz foo_;"
653 " Baz bar_;"
654 "};";
655 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
656 forField(hasType(recordDecl(hasName("Baz"))))))));
657 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
658 forField(hasName("foo_"))))));
659 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
660 forField(hasType(recordDecl(hasName("Bar"))))))));
661 }
662
TEST(HasAnyConstructorInitializer,WithInitializer)663 TEST(HasAnyConstructorInitializer, WithInitializer) {
664 static const char Code[] =
665 "class Foo {"
666 " Foo() : foo_(0) { }"
667 " int foo_;"
668 "};";
669 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
670 withInitializer(integerLiteral(equals(0)))))));
671 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
672 withInitializer(integerLiteral(equals(1)))))));
673 }
674
TEST(HasAnyConstructorInitializer,IsWritten)675 TEST(HasAnyConstructorInitializer, IsWritten) {
676 static const char Code[] =
677 "struct Bar { Bar(){} };"
678 "class Foo {"
679 " Foo() : foo_() { }"
680 " Bar foo_;"
681 " Bar bar_;"
682 "};";
683 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
684 allOf(forField(hasName("foo_")), isWritten())))));
685 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
686 allOf(forField(hasName("bar_")), isWritten())))));
687 EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
688 allOf(forField(hasName("bar_")), unless(isWritten()))))));
689 }
690
TEST(HasAnyConstructorInitializer,IsBaseInitializer)691 TEST(HasAnyConstructorInitializer, IsBaseInitializer) {
692 static const char Code[] =
693 "struct B {};"
694 "struct D : B {"
695 " int I;"
696 " D(int i) : I(i) {}"
697 "};"
698 "struct E : B {"
699 " E() : B() {}"
700 "};";
701 EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
702 hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
703 hasName("E")))));
704 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
705 hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
706 hasName("D")))));
707 EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
708 hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
709 hasName("D")))));
710 EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
711 hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
712 hasName("E")))));
713 }
714
TEST(IfStmt,ChildTraversalMatchers)715 TEST(IfStmt, ChildTraversalMatchers) {
716 EXPECT_TRUE(matches("void f() { if (false) true; else false; }",
717 ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
718 EXPECT_TRUE(notMatches("void f() { if (false) false; else true; }",
719 ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
720 EXPECT_TRUE(matches("void f() { if (false) false; else true; }",
721 ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
722 EXPECT_TRUE(notMatches("void f() { if (false) true; else false; }",
723 ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
724 }
725
TEST(MatchBinaryOperator,HasOperatorName)726 TEST(MatchBinaryOperator, HasOperatorName) {
727 StatementMatcher OperatorOr = binaryOperator(hasOperatorName("||"));
728
729 EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
730 EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
731 }
732
TEST(MatchBinaryOperator,HasLHSAndHasRHS)733 TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
734 StatementMatcher OperatorTrueFalse =
735 binaryOperator(hasLHS(cxxBoolLiteral(equals(true))),
736 hasRHS(cxxBoolLiteral(equals(false))));
737
738 EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
739 EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
740 EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
741
742 StatementMatcher OperatorIntPointer = arraySubscriptExpr(
743 hasLHS(hasType(isInteger())), hasRHS(hasType(pointsTo(qualType()))));
744 EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
745 EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
746 }
747
TEST(MatchBinaryOperator,HasEitherOperand)748 TEST(MatchBinaryOperator, HasEitherOperand) {
749 StatementMatcher HasOperand =
750 binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false))));
751
752 EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
753 EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
754 EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
755 }
756
TEST(Matcher,BinaryOperatorTypes)757 TEST(Matcher, BinaryOperatorTypes) {
758 // Integration test that verifies the AST provides all binary operators in
759 // a way we expect.
760 // FIXME: Operator ','
761 EXPECT_TRUE(
762 matches("void x() { 3, 4; }", binaryOperator(hasOperatorName(","))));
763 EXPECT_TRUE(
764 matches("bool b; bool c = (b = true);",
765 binaryOperator(hasOperatorName("="))));
766 EXPECT_TRUE(
767 matches("bool b = 1 != 2;", binaryOperator(hasOperatorName("!="))));
768 EXPECT_TRUE(
769 matches("bool b = 1 == 2;", binaryOperator(hasOperatorName("=="))));
770 EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
771 EXPECT_TRUE(
772 matches("bool b = 1 <= 2;", binaryOperator(hasOperatorName("<="))));
773 EXPECT_TRUE(
774 matches("int i = 1 << 2;", binaryOperator(hasOperatorName("<<"))));
775 EXPECT_TRUE(
776 matches("int i = 1; int j = (i <<= 2);",
777 binaryOperator(hasOperatorName("<<="))));
778 EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
779 EXPECT_TRUE(
780 matches("bool b = 1 >= 2;", binaryOperator(hasOperatorName(">="))));
781 EXPECT_TRUE(
782 matches("int i = 1 >> 2;", binaryOperator(hasOperatorName(">>"))));
783 EXPECT_TRUE(
784 matches("int i = 1; int j = (i >>= 2);",
785 binaryOperator(hasOperatorName(">>="))));
786 EXPECT_TRUE(
787 matches("int i = 42 ^ 23;", binaryOperator(hasOperatorName("^"))));
788 EXPECT_TRUE(
789 matches("int i = 42; int j = (i ^= 42);",
790 binaryOperator(hasOperatorName("^="))));
791 EXPECT_TRUE(
792 matches("int i = 42 % 23;", binaryOperator(hasOperatorName("%"))));
793 EXPECT_TRUE(
794 matches("int i = 42; int j = (i %= 42);",
795 binaryOperator(hasOperatorName("%="))));
796 EXPECT_TRUE(
797 matches("bool b = 42 &23;", binaryOperator(hasOperatorName("&"))));
798 EXPECT_TRUE(
799 matches("bool b = true && false;",
800 binaryOperator(hasOperatorName("&&"))));
801 EXPECT_TRUE(
802 matches("bool b = true; bool c = (b &= false);",
803 binaryOperator(hasOperatorName("&="))));
804 EXPECT_TRUE(
805 matches("bool b = 42 | 23;", binaryOperator(hasOperatorName("|"))));
806 EXPECT_TRUE(
807 matches("bool b = true || false;",
808 binaryOperator(hasOperatorName("||"))));
809 EXPECT_TRUE(
810 matches("bool b = true; bool c = (b |= false);",
811 binaryOperator(hasOperatorName("|="))));
812 EXPECT_TRUE(
813 matches("int i = 42 *23;", binaryOperator(hasOperatorName("*"))));
814 EXPECT_TRUE(
815 matches("int i = 42; int j = (i *= 23);",
816 binaryOperator(hasOperatorName("*="))));
817 EXPECT_TRUE(
818 matches("int i = 42 / 23;", binaryOperator(hasOperatorName("/"))));
819 EXPECT_TRUE(
820 matches("int i = 42; int j = (i /= 23);",
821 binaryOperator(hasOperatorName("/="))));
822 EXPECT_TRUE(
823 matches("int i = 42 + 23;", binaryOperator(hasOperatorName("+"))));
824 EXPECT_TRUE(
825 matches("int i = 42; int j = (i += 23);",
826 binaryOperator(hasOperatorName("+="))));
827 EXPECT_TRUE(
828 matches("int i = 42 - 23;", binaryOperator(hasOperatorName("-"))));
829 EXPECT_TRUE(
830 matches("int i = 42; int j = (i -= 23);",
831 binaryOperator(hasOperatorName("-="))));
832 EXPECT_TRUE(
833 matches("struct A { void x() { void (A::*a)(); (this->*a)(); } };",
834 binaryOperator(hasOperatorName("->*"))));
835 EXPECT_TRUE(
836 matches("struct A { void x() { void (A::*a)(); ((*this).*a)(); } };",
837 binaryOperator(hasOperatorName(".*"))));
838
839 // Member expressions as operators are not supported in matches.
840 EXPECT_TRUE(
841 notMatches("struct A { void x(A *a) { a->x(this); } };",
842 binaryOperator(hasOperatorName("->"))));
843
844 // Initializer assignments are not represented as operator equals.
845 EXPECT_TRUE(
846 notMatches("bool b = true;", binaryOperator(hasOperatorName("="))));
847
848 // Array indexing is not represented as operator.
849 EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));
850
851 // Overloaded operators do not match at all.
852 EXPECT_TRUE(notMatches(
853 "struct A { bool operator&&(const A &a) const { return false; } };"
854 "void x() { A a, b; a && b; }",
855 binaryOperator()));
856 }
857
TEST(MatchUnaryOperator,HasOperatorName)858 TEST(MatchUnaryOperator, HasOperatorName) {
859 StatementMatcher OperatorNot = unaryOperator(hasOperatorName("!"));
860
861 EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
862 EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
863 }
864
TEST(MatchUnaryOperator,HasUnaryOperand)865 TEST(MatchUnaryOperator, HasUnaryOperand) {
866 StatementMatcher OperatorOnFalse =
867 unaryOperator(hasUnaryOperand(cxxBoolLiteral(equals(false))));
868
869 EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
870 EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));
871 }
872
TEST(Matcher,UnaryOperatorTypes)873 TEST(Matcher, UnaryOperatorTypes) {
874 // Integration test that verifies the AST provides all unary operators in
875 // a way we expect.
876 EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
877 EXPECT_TRUE(
878 matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
879 EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
880 EXPECT_TRUE(
881 matches("bool *p; bool b = *p;", unaryOperator(hasOperatorName("*"))));
882 EXPECT_TRUE(
883 matches("int i; int j = +i;", unaryOperator(hasOperatorName("+"))));
884 EXPECT_TRUE(
885 matches("int i; int j = -i;", unaryOperator(hasOperatorName("-"))));
886 EXPECT_TRUE(
887 matches("int i; int j = ++i;", unaryOperator(hasOperatorName("++"))));
888 EXPECT_TRUE(
889 matches("int i; int j = i++;", unaryOperator(hasOperatorName("++"))));
890 EXPECT_TRUE(
891 matches("int i; int j = --i;", unaryOperator(hasOperatorName("--"))));
892 EXPECT_TRUE(
893 matches("int i; int j = i--;", unaryOperator(hasOperatorName("--"))));
894
895 // We don't match conversion operators.
896 EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));
897
898 // Function calls are not represented as operator.
899 EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));
900
901 // Overloaded operators do not match at all.
902 // FIXME: We probably want to add that.
903 EXPECT_TRUE(notMatches(
904 "struct A { bool operator!() const { return false; } };"
905 "void x() { A a; !a; }", unaryOperator(hasOperatorName("!"))));
906 }
907
TEST(ArraySubscriptMatchers,ArrayIndex)908 TEST(ArraySubscriptMatchers, ArrayIndex) {
909 EXPECT_TRUE(matches(
910 "int i[2]; void f() { i[1] = 1; }",
911 arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
912 EXPECT_TRUE(matches(
913 "int i[2]; void f() { 1[i] = 1; }",
914 arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
915 EXPECT_TRUE(notMatches(
916 "int i[2]; void f() { i[1] = 1; }",
917 arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
918 }
919
TEST(ArraySubscriptMatchers,MatchesArrayBase)920 TEST(ArraySubscriptMatchers, MatchesArrayBase) {
921 EXPECT_TRUE(matches(
922 "int i[2]; void f() { i[1] = 2; }",
923 arraySubscriptExpr(hasBase(implicitCastExpr(
924 hasSourceExpression(declRefExpr()))))));
925 }
926
TEST(Matcher,OfClass)927 TEST(Matcher, OfClass) {
928 StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
929 ofClass(hasName("X")))));
930
931 EXPECT_TRUE(
932 matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
933 EXPECT_TRUE(
934 matches("class X { public: X(); }; void x(int) { X x = X(); }",
935 Constructor));
936 EXPECT_TRUE(
937 notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
938 Constructor));
939 }
940
TEST(Matcher,VisitsTemplateInstantiations)941 TEST(Matcher, VisitsTemplateInstantiations) {
942 EXPECT_TRUE(matches(
943 "class A { public: void x(); };"
944 "template <typename T> class B { public: void y() { T t; t.x(); } };"
945 "void f() { B<A> b; b.y(); }",
946 callExpr(callee(cxxMethodDecl(hasName("x"))))));
947
948 EXPECT_TRUE(matches(
949 "class A { public: void x(); };"
950 "class C {"
951 " public:"
952 " template <typename T> class B { public: void y() { T t; t.x(); } };"
953 "};"
954 "void f() {"
955 " C::B<A> b; b.y();"
956 "}",
957 recordDecl(hasName("C"), hasDescendant(callExpr(
958 callee(cxxMethodDecl(hasName("x"))))))));
959 }
960
TEST(Matcher,HasCondition)961 TEST(Matcher, HasCondition) {
962 StatementMatcher IfStmt =
963 ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
964 EXPECT_TRUE(matches("void x() { if (true) {} }", IfStmt));
965 EXPECT_TRUE(notMatches("void x() { if (false) {} }", IfStmt));
966
967 StatementMatcher ForStmt =
968 forStmt(hasCondition(cxxBoolLiteral(equals(true))));
969 EXPECT_TRUE(matches("void x() { for (;true;) {} }", ForStmt));
970 EXPECT_TRUE(notMatches("void x() { for (;false;) {} }", ForStmt));
971
972 StatementMatcher WhileStmt =
973 whileStmt(hasCondition(cxxBoolLiteral(equals(true))));
974 EXPECT_TRUE(matches("void x() { while (true) {} }", WhileStmt));
975 EXPECT_TRUE(notMatches("void x() { while (false) {} }", WhileStmt));
976
977 StatementMatcher SwitchStmt =
978 switchStmt(hasCondition(integerLiteral(equals(42))));
979 EXPECT_TRUE(matches("void x() { switch (42) {case 42:;} }", SwitchStmt));
980 EXPECT_TRUE(notMatches("void x() { switch (43) {case 43:;} }", SwitchStmt));
981 }
982
TEST(For,ForLoopInternals)983 TEST(For, ForLoopInternals) {
984 EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
985 forStmt(hasCondition(anything()))));
986 EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
987 forStmt(hasLoopInit(anything()))));
988 }
989
TEST(For,ForRangeLoopInternals)990 TEST(For, ForRangeLoopInternals) {
991 EXPECT_TRUE(matches("void f(){ int a[] {1, 2}; for (int i : a); }",
992 cxxForRangeStmt(hasLoopVariable(anything()))));
993 EXPECT_TRUE(matches(
994 "void f(){ int a[] {1, 2}; for (int i : a); }",
995 cxxForRangeStmt(hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))))));
996 }
997
TEST(For,NegativeForLoopInternals)998 TEST(For, NegativeForLoopInternals) {
999 EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
1000 forStmt(hasCondition(expr()))));
1001 EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
1002 forStmt(hasLoopInit(anything()))));
1003 }
1004
TEST(HasBody,FindsBodyOfForWhileDoLoops)1005 TEST(HasBody, FindsBodyOfForWhileDoLoops) {
1006 EXPECT_TRUE(matches("void f() { for(;;) {} }",
1007 forStmt(hasBody(compoundStmt()))));
1008 EXPECT_TRUE(notMatches("void f() { for(;;); }",
1009 forStmt(hasBody(compoundStmt()))));
1010 EXPECT_TRUE(matches("void f() { while(true) {} }",
1011 whileStmt(hasBody(compoundStmt()))));
1012 EXPECT_TRUE(matches("void f() { do {} while(true); }",
1013 doStmt(hasBody(compoundStmt()))));
1014 EXPECT_TRUE(matches("void f() { int p[2]; for (auto x : p) {} }",
1015 cxxForRangeStmt(hasBody(compoundStmt()))));
1016 EXPECT_TRUE(matches("void f() {}", functionDecl(hasBody(compoundStmt()))));
1017 EXPECT_TRUE(notMatches("void f();", functionDecl(hasBody(compoundStmt()))));
1018 EXPECT_TRUE(matches("void f(); void f() {}",
1019 functionDecl(hasBody(compoundStmt()))));
1020 }
1021
TEST(HasAnySubstatement,MatchesForTopLevelCompoundStatement)1022 TEST(HasAnySubstatement, MatchesForTopLevelCompoundStatement) {
1023 // The simplest case: every compound statement is in a function
1024 // definition, and the function body itself must be a compound
1025 // statement.
1026 EXPECT_TRUE(matches("void f() { for (;;); }",
1027 compoundStmt(hasAnySubstatement(forStmt()))));
1028 }
1029
TEST(HasAnySubstatement,IsNotRecursive)1030 TEST(HasAnySubstatement, IsNotRecursive) {
1031 // It's really "has any immediate substatement".
1032 EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
1033 compoundStmt(hasAnySubstatement(forStmt()))));
1034 }
1035
TEST(HasAnySubstatement,MatchesInNestedCompoundStatements)1036 TEST(HasAnySubstatement, MatchesInNestedCompoundStatements) {
1037 EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
1038 compoundStmt(hasAnySubstatement(forStmt()))));
1039 }
1040
TEST(HasAnySubstatement,FindsSubstatementBetweenOthers)1041 TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
1042 EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
1043 compoundStmt(hasAnySubstatement(forStmt()))));
1044 }
1045
TEST(Member,MatchesMemberAllocationFunction)1046 TEST(Member, MatchesMemberAllocationFunction) {
1047 // Fails in C++11 mode
1048 EXPECT_TRUE(matchesConditionally(
1049 "namespace std { typedef typeof(sizeof(int)) size_t; }"
1050 "class X { void *operator new(std::size_t); };",
1051 cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
1052
1053 EXPECT_TRUE(matches("class X { void operator delete(void*); };",
1054 cxxMethodDecl(ofClass(hasName("X")))));
1055
1056 // Fails in C++11 mode
1057 EXPECT_TRUE(matchesConditionally(
1058 "namespace std { typedef typeof(sizeof(int)) size_t; }"
1059 "class X { void operator delete[](void*, std::size_t); };",
1060 cxxMethodDecl(ofClass(hasName("X"))), true, "-std=gnu++98"));
1061 }
1062
TEST(HasDestinationType,MatchesSimpleCase)1063 TEST(HasDestinationType, MatchesSimpleCase) {
1064 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1065 cxxStaticCastExpr(hasDestinationType(
1066 pointsTo(TypeMatcher(anything()))))));
1067 }
1068
TEST(HasImplicitDestinationType,MatchesSimpleCase)1069 TEST(HasImplicitDestinationType, MatchesSimpleCase) {
1070 // This test creates an implicit const cast.
1071 EXPECT_TRUE(matches("int x; const int i = x;",
1072 implicitCastExpr(
1073 hasImplicitDestinationType(isInteger()))));
1074 // This test creates an implicit array-to-pointer cast.
1075 EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
1076 implicitCastExpr(hasImplicitDestinationType(
1077 pointsTo(TypeMatcher(anything()))))));
1078 }
1079
TEST(HasImplicitDestinationType,DoesNotMatchIncorrectly)1080 TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
1081 // This test creates an implicit cast from int to char.
1082 EXPECT_TRUE(notMatches("char c = 0;",
1083 implicitCastExpr(hasImplicitDestinationType(
1084 unless(anything())))));
1085 // This test creates an implicit array-to-pointer cast.
1086 EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
1087 implicitCastExpr(hasImplicitDestinationType(
1088 unless(anything())))));
1089 }
1090
TEST(IgnoringImplicit,MatchesImplicit)1091 TEST(IgnoringImplicit, MatchesImplicit) {
1092 EXPECT_TRUE(matches("class C {}; C a = C();",
1093 varDecl(has(ignoringImplicit(cxxConstructExpr())))));
1094 }
1095
TEST(IgnoringImplicit,DoesNotMatchIncorrectly)1096 TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
1097 EXPECT_TRUE(
1098 notMatches("class C {}; C a = C();", varDecl(has(cxxConstructExpr()))));
1099 }
1100
TEST(IgnoringImpCasts,MatchesImpCasts)1101 TEST(IgnoringImpCasts, MatchesImpCasts) {
1102 // This test checks that ignoringImpCasts matches when implicit casts are
1103 // present and its inner matcher alone does not match.
1104 // Note that this test creates an implicit const cast.
1105 EXPECT_TRUE(matches("int x = 0; const int y = x;",
1106 varDecl(hasInitializer(ignoringImpCasts(
1107 declRefExpr(to(varDecl(hasName("x")))))))));
1108 // This test creates an implict cast from int to char.
1109 EXPECT_TRUE(matches("char x = 0;",
1110 varDecl(hasInitializer(ignoringImpCasts(
1111 integerLiteral(equals(0)))))));
1112 }
1113
TEST(IgnoringImpCasts,DoesNotMatchIncorrectly)1114 TEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
1115 // These tests verify that ignoringImpCasts does not match if the inner
1116 // matcher does not match.
1117 // Note that the first test creates an implicit const cast.
1118 EXPECT_TRUE(notMatches("int x; const int y = x;",
1119 varDecl(hasInitializer(ignoringImpCasts(
1120 unless(anything()))))));
1121 EXPECT_TRUE(notMatches("int x; int y = x;",
1122 varDecl(hasInitializer(ignoringImpCasts(
1123 unless(anything()))))));
1124
1125 // These tests verify that ignoringImplictCasts does not look through explicit
1126 // casts or parentheses.
1127 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1128 varDecl(hasInitializer(ignoringImpCasts(
1129 integerLiteral())))));
1130 EXPECT_TRUE(notMatches("int i = (0);",
1131 varDecl(hasInitializer(ignoringImpCasts(
1132 integerLiteral())))));
1133 EXPECT_TRUE(notMatches("float i = (float)0;",
1134 varDecl(hasInitializer(ignoringImpCasts(
1135 integerLiteral())))));
1136 EXPECT_TRUE(notMatches("float i = float(0);",
1137 varDecl(hasInitializer(ignoringImpCasts(
1138 integerLiteral())))));
1139 }
1140
TEST(IgnoringImpCasts,MatchesWithoutImpCasts)1141 TEST(IgnoringImpCasts, MatchesWithoutImpCasts) {
1142 // This test verifies that expressions that do not have implicit casts
1143 // still match the inner matcher.
1144 EXPECT_TRUE(matches("int x = 0; int &y = x;",
1145 varDecl(hasInitializer(ignoringImpCasts(
1146 declRefExpr(to(varDecl(hasName("x")))))))));
1147 }
1148
TEST(IgnoringParenCasts,MatchesParenCasts)1149 TEST(IgnoringParenCasts, MatchesParenCasts) {
1150 // This test checks that ignoringParenCasts matches when parentheses and/or
1151 // casts are present and its inner matcher alone does not match.
1152 EXPECT_TRUE(matches("int x = (0);",
1153 varDecl(hasInitializer(ignoringParenCasts(
1154 integerLiteral(equals(0)))))));
1155 EXPECT_TRUE(matches("int x = (((((0)))));",
1156 varDecl(hasInitializer(ignoringParenCasts(
1157 integerLiteral(equals(0)))))));
1158
1159 // This test creates an implict cast from int to char in addition to the
1160 // parentheses.
1161 EXPECT_TRUE(matches("char x = (0);",
1162 varDecl(hasInitializer(ignoringParenCasts(
1163 integerLiteral(equals(0)))))));
1164
1165 EXPECT_TRUE(matches("char x = (char)0;",
1166 varDecl(hasInitializer(ignoringParenCasts(
1167 integerLiteral(equals(0)))))));
1168 EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
1169 varDecl(hasInitializer(ignoringParenCasts(
1170 integerLiteral(equals(0)))))));
1171 }
1172
TEST(IgnoringParenCasts,MatchesWithoutParenCasts)1173 TEST(IgnoringParenCasts, MatchesWithoutParenCasts) {
1174 // This test verifies that expressions that do not have any casts still match.
1175 EXPECT_TRUE(matches("int x = 0;",
1176 varDecl(hasInitializer(ignoringParenCasts(
1177 integerLiteral(equals(0)))))));
1178 }
1179
TEST(IgnoringParenCasts,DoesNotMatchIncorrectly)1180 TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) {
1181 // These tests verify that ignoringImpCasts does not match if the inner
1182 // matcher does not match.
1183 EXPECT_TRUE(notMatches("int x = ((0));",
1184 varDecl(hasInitializer(ignoringParenCasts(
1185 unless(anything()))))));
1186
1187 // This test creates an implicit cast from int to char in addition to the
1188 // parentheses.
1189 EXPECT_TRUE(notMatches("char x = ((0));",
1190 varDecl(hasInitializer(ignoringParenCasts(
1191 unless(anything()))))));
1192
1193 EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
1194 varDecl(hasInitializer(ignoringParenCasts(
1195 unless(anything()))))));
1196 }
1197
TEST(IgnoringParenAndImpCasts,MatchesParenImpCasts)1198 TEST(IgnoringParenAndImpCasts, MatchesParenImpCasts) {
1199 // This test checks that ignoringParenAndImpCasts matches when
1200 // parentheses and/or implicit casts are present and its inner matcher alone
1201 // does not match.
1202 // Note that this test creates an implicit const cast.
1203 EXPECT_TRUE(matches("int x = 0; const int y = x;",
1204 varDecl(hasInitializer(ignoringParenImpCasts(
1205 declRefExpr(to(varDecl(hasName("x")))))))));
1206 // This test creates an implicit cast from int to char.
1207 EXPECT_TRUE(matches("const char x = (0);",
1208 varDecl(hasInitializer(ignoringParenImpCasts(
1209 integerLiteral(equals(0)))))));
1210 }
1211
TEST(IgnoringParenAndImpCasts,MatchesWithoutParenImpCasts)1212 TEST(IgnoringParenAndImpCasts, MatchesWithoutParenImpCasts) {
1213 // This test verifies that expressions that do not have parentheses or
1214 // implicit casts still match.
1215 EXPECT_TRUE(matches("int x = 0; int &y = x;",
1216 varDecl(hasInitializer(ignoringParenImpCasts(
1217 declRefExpr(to(varDecl(hasName("x")))))))));
1218 EXPECT_TRUE(matches("int x = 0;",
1219 varDecl(hasInitializer(ignoringParenImpCasts(
1220 integerLiteral(equals(0)))))));
1221 }
1222
TEST(IgnoringParenAndImpCasts,DoesNotMatchIncorrectly)1223 TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) {
1224 // These tests verify that ignoringParenImpCasts does not match if
1225 // the inner matcher does not match.
1226 // This test creates an implicit cast.
1227 EXPECT_TRUE(notMatches("char c = ((3));",
1228 varDecl(hasInitializer(ignoringParenImpCasts(
1229 unless(anything()))))));
1230 // These tests verify that ignoringParenAndImplictCasts does not look
1231 // through explicit casts.
1232 EXPECT_TRUE(notMatches("float y = (float(0));",
1233 varDecl(hasInitializer(ignoringParenImpCasts(
1234 integerLiteral())))));
1235 EXPECT_TRUE(notMatches("float y = (float)0;",
1236 varDecl(hasInitializer(ignoringParenImpCasts(
1237 integerLiteral())))));
1238 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
1239 varDecl(hasInitializer(ignoringParenImpCasts(
1240 integerLiteral())))));
1241 }
1242
TEST(HasSourceExpression,MatchesImplicitCasts)1243 TEST(HasSourceExpression, MatchesImplicitCasts) {
1244 EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
1245 "void r() {string a_string; URL url = a_string; }",
1246 implicitCastExpr(
1247 hasSourceExpression(cxxConstructExpr()))));
1248 }
1249
TEST(HasSourceExpression,MatchesExplicitCasts)1250 TEST(HasSourceExpression, MatchesExplicitCasts) {
1251 EXPECT_TRUE(matches("float x = static_cast<float>(42);",
1252 explicitCastExpr(
1253 hasSourceExpression(hasDescendant(
1254 expr(integerLiteral()))))));
1255 }
1256
TEST(UsingDeclaration,MatchesSpecificTarget)1257 TEST(UsingDeclaration, MatchesSpecificTarget) {
1258 EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
1259 usingDecl(hasAnyUsingShadowDecl(
1260 hasTargetDecl(functionDecl())))));
1261 EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
1262 usingDecl(hasAnyUsingShadowDecl(
1263 hasTargetDecl(functionDecl())))));
1264 }
1265
TEST(UsingDeclaration,ThroughUsingDeclaration)1266 TEST(UsingDeclaration, ThroughUsingDeclaration) {
1267 EXPECT_TRUE(matches(
1268 "namespace a { void f(); } using a::f; void g() { f(); }",
1269 declRefExpr(throughUsingDecl(anything()))));
1270 EXPECT_TRUE(notMatches(
1271 "namespace a { void f(); } using a::f; void g() { a::f(); }",
1272 declRefExpr(throughUsingDecl(anything()))));
1273 }
1274
TEST(SingleDecl,IsSingleDecl)1275 TEST(SingleDecl, IsSingleDecl) {
1276 StatementMatcher SingleDeclStmt =
1277 declStmt(hasSingleDecl(varDecl(hasInitializer(anything()))));
1278 EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
1279 EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
1280 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1281 SingleDeclStmt));
1282 }
1283
TEST(DeclStmt,ContainsDeclaration)1284 TEST(DeclStmt, ContainsDeclaration) {
1285 DeclarationMatcher MatchesInit = varDecl(hasInitializer(anything()));
1286
1287 EXPECT_TRUE(matches("void f() {int a = 4;}",
1288 declStmt(containsDeclaration(0, MatchesInit))));
1289 EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
1290 declStmt(containsDeclaration(0, MatchesInit),
1291 containsDeclaration(1, MatchesInit))));
1292 unsigned WrongIndex = 42;
1293 EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
1294 declStmt(containsDeclaration(WrongIndex,
1295 MatchesInit))));
1296 }
1297
TEST(SwitchCase,MatchesEachCase)1298 TEST(SwitchCase, MatchesEachCase) {
1299 EXPECT_TRUE(notMatches("void x() { switch(42); }",
1300 switchStmt(forEachSwitchCase(caseStmt()))));
1301 EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
1302 switchStmt(forEachSwitchCase(caseStmt()))));
1303 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
1304 switchStmt(forEachSwitchCase(caseStmt()))));
1305 EXPECT_TRUE(notMatches(
1306 "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
1307 ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
1308 EXPECT_TRUE(matches("void x() { switch(42) { case 1+1: case 4:; } }",
1309 switchStmt(forEachSwitchCase(
1310 caseStmt(hasCaseConstant(integerLiteral()))))));
1311 EXPECT_TRUE(notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
1312 switchStmt(forEachSwitchCase(
1313 caseStmt(hasCaseConstant(integerLiteral()))))));
1314 EXPECT_TRUE(notMatches("void x() { switch(42) { case 1 ... 2:; } }",
1315 switchStmt(forEachSwitchCase(
1316 caseStmt(hasCaseConstant(integerLiteral()))))));
1317 EXPECT_TRUE(matchAndVerifyResultTrue(
1318 "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
1319 switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
1320 llvm::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
1321 }
1322
TEST(ForEachConstructorInitializer,MatchesInitializers)1323 TEST(ForEachConstructorInitializer, MatchesInitializers) {
1324 EXPECT_TRUE(matches(
1325 "struct X { X() : i(42), j(42) {} int i, j; };",
1326 cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
1327 }
1328
TEST(HasConditionVariableStatement,DoesNotMatchCondition)1329 TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
1330 EXPECT_TRUE(notMatches(
1331 "void x() { if(true) {} }",
1332 ifStmt(hasConditionVariableStatement(declStmt()))));
1333 EXPECT_TRUE(notMatches(
1334 "void x() { int x; if((x = 42)) {} }",
1335 ifStmt(hasConditionVariableStatement(declStmt()))));
1336 }
1337
TEST(HasConditionVariableStatement,MatchesConditionVariables)1338 TEST(HasConditionVariableStatement, MatchesConditionVariables) {
1339 EXPECT_TRUE(matches(
1340 "void x() { if(int* a = 0) {} }",
1341 ifStmt(hasConditionVariableStatement(declStmt()))));
1342 }
1343
TEST(ForEach,BindsOneNode)1344 TEST(ForEach, BindsOneNode) {
1345 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
1346 recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
1347 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1348 }
1349
TEST(ForEach,BindsMultipleNodes)1350 TEST(ForEach, BindsMultipleNodes) {
1351 EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
1352 recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
1353 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 3)));
1354 }
1355
TEST(ForEach,BindsRecursiveCombinations)1356 TEST(ForEach, BindsRecursiveCombinations) {
1357 EXPECT_TRUE(matchAndVerifyResultTrue(
1358 "class C { class D { int x; int y; }; class E { int y; int z; }; };",
1359 recordDecl(hasName("C"),
1360 forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
1361 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1362 }
1363
TEST(ForEachDescendant,BindsOneNode)1364 TEST(ForEachDescendant, BindsOneNode) {
1365 EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
1366 recordDecl(hasName("C"),
1367 forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
1368 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
1369 }
1370
TEST(ForEachDescendant,NestedForEachDescendant)1371 TEST(ForEachDescendant, NestedForEachDescendant) {
1372 DeclarationMatcher m = recordDecl(
1373 isDefinition(), decl().bind("x"), hasName("C"));
1374 EXPECT_TRUE(matchAndVerifyResultTrue(
1375 "class A { class B { class C {}; }; };",
1376 recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
1377 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1378
1379 // Check that a partial match of 'm' that binds 'x' in the
1380 // first part of anyOf(m, anything()) will not overwrite the
1381 // binding created by the earlier binding in the hasDescendant.
1382 EXPECT_TRUE(matchAndVerifyResultTrue(
1383 "class A { class B { class C {}; }; };",
1384 recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
1385 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
1386 }
1387
TEST(ForEachDescendant,BindsMultipleNodes)1388 TEST(ForEachDescendant, BindsMultipleNodes) {
1389 EXPECT_TRUE(matchAndVerifyResultTrue(
1390 "class C { class D { int x; int y; }; "
1391 " class E { class F { int y; int z; }; }; };",
1392 recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
1393 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
1394 }
1395
TEST(ForEachDescendant,BindsRecursiveCombinations)1396 TEST(ForEachDescendant, BindsRecursiveCombinations) {
1397 EXPECT_TRUE(matchAndVerifyResultTrue(
1398 "class C { class D { "
1399 " class E { class F { class G { int y; int z; }; }; }; }; };",
1400 recordDecl(hasName("C"), forEachDescendant(recordDecl(
1401 forEachDescendant(fieldDecl().bind("f"))))),
1402 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 8)));
1403 }
1404
TEST(ForEachDescendant,BindsCombinations)1405 TEST(ForEachDescendant, BindsCombinations) {
1406 EXPECT_TRUE(matchAndVerifyResultTrue(
1407 "void f() { if(true) {} if (true) {} while (true) {} if (true) {} while "
1408 "(true) {} }",
1409 compoundStmt(forEachDescendant(ifStmt().bind("if")),
1410 forEachDescendant(whileStmt().bind("while"))),
1411 llvm::make_unique<VerifyIdIsBoundTo<IfStmt>>("if", 6)));
1412 }
1413
TEST(Has,DoesNotDeleteBindings)1414 TEST(Has, DoesNotDeleteBindings) {
1415 EXPECT_TRUE(matchAndVerifyResultTrue(
1416 "class X { int a; };", recordDecl(decl().bind("x"), has(fieldDecl())),
1417 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1418 }
1419
TEST(LoopingMatchers,DoNotOverwritePreviousMatchResultOnFailure)1420 TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
1421 // Those matchers cover all the cases where an inner matcher is called
1422 // and there is not a 1:1 relationship between the match of the outer
1423 // matcher and the match of the inner matcher.
1424 // The pattern to look for is:
1425 // ... return InnerMatcher.matches(...); ...
1426 // In which case no special handling is needed.
1427 //
1428 // On the other hand, if there are multiple alternative matches
1429 // (for example forEach*) or matches might be discarded (for example has*)
1430 // the implementation must make sure that the discarded matches do not
1431 // affect the bindings.
1432 // When new such matchers are added, add a test here that:
1433 // - matches a simple node, and binds it as the first thing in the matcher:
1434 // recordDecl(decl().bind("x"), hasName("X")))
1435 // - uses the matcher under test afterwards in a way that not the first
1436 // alternative is matched; for anyOf, that means the first branch
1437 // would need to return false; for hasAncestor, it means that not
1438 // the direct parent matches the inner matcher.
1439
1440 EXPECT_TRUE(matchAndVerifyResultTrue(
1441 "class X { int y; };",
1442 recordDecl(
1443 recordDecl().bind("x"), hasName("::X"),
1444 anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
1445 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
1446 EXPECT_TRUE(matchAndVerifyResultTrue(
1447 "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
1448 anyOf(unless(anything()), anything())),
1449 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
1450 EXPECT_TRUE(matchAndVerifyResultTrue(
1451 "template<typename T1, typename T2> class X {}; X<float, int> x;",
1452 classTemplateSpecializationDecl(
1453 decl().bind("x"),
1454 hasAnyTemplateArgument(refersToType(asString("int")))),
1455 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1456 EXPECT_TRUE(matchAndVerifyResultTrue(
1457 "class X { void f(); void g(); };",
1458 cxxRecordDecl(decl().bind("x"), hasMethod(hasName("g"))),
1459 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1460 EXPECT_TRUE(matchAndVerifyResultTrue(
1461 "class X { X() : a(1), b(2) {} double a; int b; };",
1462 recordDecl(decl().bind("x"),
1463 has(cxxConstructorDecl(
1464 hasAnyConstructorInitializer(forField(hasName("b")))))),
1465 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1466 EXPECT_TRUE(matchAndVerifyResultTrue(
1467 "void x(int, int) { x(0, 42); }",
1468 callExpr(expr().bind("x"), hasAnyArgument(integerLiteral(equals(42)))),
1469 llvm::make_unique<VerifyIdIsBoundTo<Expr>>("x", 1)));
1470 EXPECT_TRUE(matchAndVerifyResultTrue(
1471 "void x(int, int y) {}",
1472 functionDecl(decl().bind("x"), hasAnyParameter(hasName("y"))),
1473 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1474 EXPECT_TRUE(matchAndVerifyResultTrue(
1475 "void x() { return; if (true) {} }",
1476 functionDecl(decl().bind("x"),
1477 has(compoundStmt(hasAnySubstatement(ifStmt())))),
1478 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1479 EXPECT_TRUE(matchAndVerifyResultTrue(
1480 "namespace X { void b(int); void b(); }"
1481 "using X::b;",
1482 usingDecl(decl().bind("x"), hasAnyUsingShadowDecl(hasTargetDecl(
1483 functionDecl(parameterCountIs(1))))),
1484 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1485 EXPECT_TRUE(matchAndVerifyResultTrue(
1486 "class A{}; class B{}; class C : B, A {};",
1487 cxxRecordDecl(decl().bind("x"), isDerivedFrom("::A")),
1488 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1489 EXPECT_TRUE(matchAndVerifyResultTrue(
1490 "class A{}; typedef A B; typedef A C; typedef A D;"
1491 "class E : A {};",
1492 cxxRecordDecl(decl().bind("x"), isDerivedFrom("C")),
1493 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1494 EXPECT_TRUE(matchAndVerifyResultTrue(
1495 "class A { class B { void f() {} }; };",
1496 functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
1497 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1498 EXPECT_TRUE(matchAndVerifyResultTrue(
1499 "template <typename T> struct A { struct B {"
1500 " void f() { if(true) {} }"
1501 "}; };"
1502 "void t() { A<int>::B b; b.f(); }",
1503 ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
1504 llvm::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
1505 EXPECT_TRUE(matchAndVerifyResultTrue(
1506 "class A {};",
1507 recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
1508 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1509 EXPECT_TRUE(matchAndVerifyResultTrue(
1510 "class A { A() : s(), i(42) {} const char *s; int i; };",
1511 cxxConstructorDecl(hasName("::A::A"), decl().bind("x"),
1512 forEachConstructorInitializer(forField(hasName("i")))),
1513 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
1514 }
1515
TEST(ForEachDescendant,BindsCorrectNodes)1516 TEST(ForEachDescendant, BindsCorrectNodes) {
1517 EXPECT_TRUE(matchAndVerifyResultTrue(
1518 "class C { void f(); int i; };",
1519 recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
1520 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("decl", 1)));
1521 EXPECT_TRUE(matchAndVerifyResultTrue(
1522 "class C { void f() {} int i; };",
1523 recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
1524 llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("decl", 1)));
1525 }
1526
TEST(FindAll,BindsNodeOnMatch)1527 TEST(FindAll, BindsNodeOnMatch) {
1528 EXPECT_TRUE(matchAndVerifyResultTrue(
1529 "class A {};",
1530 recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
1531 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 1)));
1532 }
1533
TEST(FindAll,BindsDescendantNodeOnMatch)1534 TEST(FindAll, BindsDescendantNodeOnMatch) {
1535 EXPECT_TRUE(matchAndVerifyResultTrue(
1536 "class A { int a; int b; };",
1537 recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
1538 llvm::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
1539 }
1540
TEST(FindAll,BindsNodeAndDescendantNodesOnOneMatch)1541 TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
1542 EXPECT_TRUE(matchAndVerifyResultTrue(
1543 "class A { int a; int b; };",
1544 recordDecl(hasName("::A"),
1545 findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
1546 fieldDecl().bind("v"))))),
1547 llvm::make_unique<VerifyIdIsBoundTo<Decl>>("v", 3)));
1548
1549 EXPECT_TRUE(matchAndVerifyResultTrue(
1550 "class A { class B {}; class C {}; };",
1551 recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
1552 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 3)));
1553 }
1554
TEST(HasAncenstor,MatchesDeclarationAncestors)1555 TEST(HasAncenstor, MatchesDeclarationAncestors) {
1556 EXPECT_TRUE(matches(
1557 "class A { class B { class C {}; }; };",
1558 recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("A"))))));
1559 }
1560
TEST(HasAncenstor,FailsIfNoAncestorMatches)1561 TEST(HasAncenstor, FailsIfNoAncestorMatches) {
1562 EXPECT_TRUE(notMatches(
1563 "class A { class B { class C {}; }; };",
1564 recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("X"))))));
1565 }
1566
TEST(HasAncestor,MatchesDeclarationsThatGetVisitedLater)1567 TEST(HasAncestor, MatchesDeclarationsThatGetVisitedLater) {
1568 EXPECT_TRUE(matches(
1569 "class A { class B { void f() { C c; } class C {}; }; };",
1570 varDecl(hasName("c"), hasType(recordDecl(hasName("C"),
1571 hasAncestor(recordDecl(hasName("A"))))))));
1572 }
1573
TEST(HasAncenstor,MatchesStatementAncestors)1574 TEST(HasAncenstor, MatchesStatementAncestors) {
1575 EXPECT_TRUE(matches(
1576 "void f() { if (true) { while (false) { 42; } } }",
1577 integerLiteral(equals(42), hasAncestor(ifStmt()))));
1578 }
1579
TEST(HasAncestor,DrillsThroughDifferentHierarchies)1580 TEST(HasAncestor, DrillsThroughDifferentHierarchies) {
1581 EXPECT_TRUE(matches(
1582 "void f() { if (true) { int x = 42; } }",
1583 integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
1584 }
1585
TEST(HasAncestor,BindsRecursiveCombinations)1586 TEST(HasAncestor, BindsRecursiveCombinations) {
1587 EXPECT_TRUE(matchAndVerifyResultTrue(
1588 "class C { class D { class E { class F { int y; }; }; }; };",
1589 fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
1590 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("r", 1)));
1591 }
1592
TEST(HasAncestor,BindsCombinationsWithHasDescendant)1593 TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
1594 EXPECT_TRUE(matchAndVerifyResultTrue(
1595 "class C { class D { class E { class F { int y; }; }; }; };",
1596 fieldDecl(hasAncestor(
1597 decl(
1598 hasDescendant(recordDecl(isDefinition(),
1599 hasAncestor(recordDecl())))
1600 ).bind("d")
1601 )),
1602 llvm::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
1603 }
1604
TEST(HasAncestor,MatchesClosestAncestor)1605 TEST(HasAncestor, MatchesClosestAncestor) {
1606 EXPECT_TRUE(matchAndVerifyResultTrue(
1607 "template <typename T> struct C {"
1608 " void f(int) {"
1609 " struct I { void g(T) { int x; } } i; i.g(42);"
1610 " }"
1611 "};"
1612 "template struct C<int>;",
1613 varDecl(hasName("x"),
1614 hasAncestor(functionDecl(hasParameter(
1615 0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
1616 llvm::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
1617 }
1618
TEST(HasAncestor,MatchesInTemplateInstantiations)1619 TEST(HasAncestor, MatchesInTemplateInstantiations) {
1620 EXPECT_TRUE(matches(
1621 "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
1622 "A<int>::B::C a;",
1623 fieldDecl(hasType(asString("int")),
1624 hasAncestor(recordDecl(hasName("A"))))));
1625 }
1626
TEST(HasAncestor,MatchesInImplicitCode)1627 TEST(HasAncestor, MatchesInImplicitCode) {
1628 EXPECT_TRUE(matches(
1629 "struct X {}; struct A { A() {} X x; };",
1630 cxxConstructorDecl(
1631 hasAnyConstructorInitializer(withInitializer(expr(
1632 hasAncestor(recordDecl(hasName("A")))))))));
1633 }
1634
TEST(HasParent,MatchesOnlyParent)1635 TEST(HasParent, MatchesOnlyParent) {
1636 EXPECT_TRUE(matches(
1637 "void f() { if (true) { int x = 42; } }",
1638 compoundStmt(hasParent(ifStmt()))));
1639 EXPECT_TRUE(notMatches(
1640 "void f() { for (;;) { int x = 42; } }",
1641 compoundStmt(hasParent(ifStmt()))));
1642 EXPECT_TRUE(notMatches(
1643 "void f() { if (true) for (;;) { int x = 42; } }",
1644 compoundStmt(hasParent(ifStmt()))));
1645 }
1646
TEST(HasAncestor,MatchesAllAncestors)1647 TEST(HasAncestor, MatchesAllAncestors) {
1648 EXPECT_TRUE(matches(
1649 "template <typename T> struct C { static void f() { 42; } };"
1650 "void t() { C<int>::f(); }",
1651 integerLiteral(
1652 equals(42),
1653 allOf(
1654 hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
1655 hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
1656 }
1657
TEST(HasAncestor,ImplicitArrayCopyCtorDeclRefExpr)1658 TEST(HasAncestor, ImplicitArrayCopyCtorDeclRefExpr) {
1659 EXPECT_TRUE(matches("struct MyClass {\n"
1660 " int c[1];\n"
1661 " static MyClass Create() { return MyClass(); }\n"
1662 "};",
1663 declRefExpr(to(decl(hasAncestor(decl()))))));
1664 }
1665
TEST(HasAncestor,AnonymousUnionMemberExpr)1666 TEST(HasAncestor, AnonymousUnionMemberExpr) {
1667 EXPECT_TRUE(matches("int F() {\n"
1668 " union { int i; };\n"
1669 " return i;\n"
1670 "}\n",
1671 memberExpr(member(hasAncestor(decl())))));
1672 EXPECT_TRUE(matches("void f() {\n"
1673 " struct {\n"
1674 " struct { int a; int b; };\n"
1675 " } s;\n"
1676 " s.a = 4;\n"
1677 "}\n",
1678 memberExpr(member(hasAncestor(decl())))));
1679 EXPECT_TRUE(matches("void f() {\n"
1680 " struct {\n"
1681 " struct { int a; int b; };\n"
1682 " } s;\n"
1683 " s.a = 4;\n"
1684 "}\n",
1685 declRefExpr(to(decl(hasAncestor(decl()))))));
1686 }
TEST(HasAncestor,NonParmDependentTemplateParmVarDeclRefExpr)1687 TEST(HasAncestor, NonParmDependentTemplateParmVarDeclRefExpr) {
1688 EXPECT_TRUE(matches("struct PartitionAllocator {\n"
1689 " template<typename T>\n"
1690 " static int quantizedSize(int count) {\n"
1691 " return count;\n"
1692 " }\n"
1693 " void f() { quantizedSize<int>(10); }\n"
1694 "};",
1695 declRefExpr(to(decl(hasAncestor(decl()))))));
1696 }
1697
TEST(HasAncestor,AddressOfExplicitSpecializationFunction)1698 TEST(HasAncestor, AddressOfExplicitSpecializationFunction) {
1699 EXPECT_TRUE(matches("template <class T> void f();\n"
1700 "template <> void f<int>();\n"
1701 "void (*get_f())() { return f<int>; }\n",
1702 declRefExpr(to(decl(hasAncestor(decl()))))));
1703 }
1704
TEST(HasParent,MatchesAllParents)1705 TEST(HasParent, MatchesAllParents) {
1706 EXPECT_TRUE(matches(
1707 "template <typename T> struct C { static void f() { 42; } };"
1708 "void t() { C<int>::f(); }",
1709 integerLiteral(
1710 equals(42),
1711 hasParent(compoundStmt(hasParent(functionDecl(
1712 hasParent(cxxRecordDecl(isTemplateInstantiation())))))))));
1713 EXPECT_TRUE(
1714 matches("template <typename T> struct C { static void f() { 42; } };"
1715 "void t() { C<int>::f(); }",
1716 integerLiteral(
1717 equals(42),
1718 hasParent(compoundStmt(hasParent(functionDecl(hasParent(
1719 cxxRecordDecl(unless(isTemplateInstantiation()))))))))));
1720 EXPECT_TRUE(matches(
1721 "template <typename T> struct C { static void f() { 42; } };"
1722 "void t() { C<int>::f(); }",
1723 integerLiteral(equals(42),
1724 hasParent(compoundStmt(
1725 allOf(hasParent(functionDecl(hasParent(
1726 cxxRecordDecl(isTemplateInstantiation())))),
1727 hasParent(functionDecl(hasParent(cxxRecordDecl(
1728 unless(isTemplateInstantiation())))))))))));
1729 EXPECT_TRUE(
1730 notMatches("template <typename T> struct C { static void f() {} };"
1731 "void t() { C<int>::f(); }",
1732 compoundStmt(hasParent(recordDecl()))));
1733 }
1734
TEST(HasParent,NoDuplicateParents)1735 TEST(HasParent, NoDuplicateParents) {
1736 class HasDuplicateParents : public BoundNodesCallback {
1737 public:
1738 bool run(const BoundNodes *Nodes) override { return false; }
1739 bool run(const BoundNodes *Nodes, ASTContext *Context) override {
1740 const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
1741 std::set<const void *> Parents;
1742 for (const auto &Parent : Context->getParents(*Node)) {
1743 if (!Parents.insert(Parent.getMemoizationData()).second) {
1744 return true;
1745 }
1746 }
1747 return false;
1748 }
1749 };
1750 EXPECT_FALSE(matchAndVerifyResultTrue(
1751 "template <typename T> int Foo() { return 1 + 2; }\n"
1752 "int x = Foo<int>() + Foo<unsigned>();",
1753 stmt().bind("node"), llvm::make_unique<HasDuplicateParents>()));
1754 }
1755
TEST(TypeMatching,PointeeTypes)1756 TEST(TypeMatching, PointeeTypes) {
1757 EXPECT_TRUE(matches("int b; int &a = b;",
1758 referenceType(pointee(builtinType()))));
1759 EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));
1760
1761 EXPECT_TRUE(matches("int *a;",
1762 loc(pointerType(pointee(builtinType())))));
1763
1764 EXPECT_TRUE(matches(
1765 "int const *A;",
1766 pointerType(pointee(isConstQualified(), builtinType()))));
1767 EXPECT_TRUE(notMatches(
1768 "int *A;",
1769 pointerType(pointee(isConstQualified(), builtinType()))));
1770 }
1771
TEST(ElaboratedTypeNarrowing,hasQualifier)1772 TEST(ElaboratedTypeNarrowing, hasQualifier) {
1773 EXPECT_TRUE(matches(
1774 "namespace N {"
1775 " namespace M {"
1776 " class D {};"
1777 " }"
1778 "}"
1779 "N::M::D d;",
1780 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
1781 EXPECT_TRUE(notMatches(
1782 "namespace M {"
1783 " class D {};"
1784 "}"
1785 "M::D d;",
1786 elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
1787 EXPECT_TRUE(notMatches(
1788 "struct D {"
1789 "} d;",
1790 elaboratedType(hasQualifier(nestedNameSpecifier()))));
1791 }
1792
TEST(ElaboratedTypeNarrowing,namesType)1793 TEST(ElaboratedTypeNarrowing, namesType) {
1794 EXPECT_TRUE(matches(
1795 "namespace N {"
1796 " namespace M {"
1797 " class D {};"
1798 " }"
1799 "}"
1800 "N::M::D d;",
1801 elaboratedType(elaboratedType(namesType(recordType(
1802 hasDeclaration(namedDecl(hasName("D")))))))));
1803 EXPECT_TRUE(notMatches(
1804 "namespace M {"
1805 " class D {};"
1806 "}"
1807 "M::D d;",
1808 elaboratedType(elaboratedType(namesType(typedefType())))));
1809 }
1810
TEST(NNS,BindsNestedNameSpecifiers)1811 TEST(NNS, BindsNestedNameSpecifiers) {
1812 EXPECT_TRUE(matchAndVerifyResultTrue(
1813 "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
1814 nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
1815 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
1816 "nns", "ns::struct E::")));
1817 }
1818
TEST(NNS,BindsNestedNameSpecifierLocs)1819 TEST(NNS, BindsNestedNameSpecifierLocs) {
1820 EXPECT_TRUE(matchAndVerifyResultTrue(
1821 "namespace ns { struct B {}; } ns::B b;",
1822 loc(nestedNameSpecifier()).bind("loc"),
1823 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("loc", 1)));
1824 }
1825
TEST(NNS,DescendantsOfNestedNameSpecifiers)1826 TEST(NNS, DescendantsOfNestedNameSpecifiers) {
1827 std::string Fragment =
1828 "namespace a { struct A { struct B { struct C {}; }; }; };"
1829 "void f() { a::A::B::C c; }";
1830 EXPECT_TRUE(matches(
1831 Fragment,
1832 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1833 hasDescendant(nestedNameSpecifier(
1834 specifiesNamespace(hasName("a")))))));
1835 EXPECT_TRUE(notMatches(
1836 Fragment,
1837 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1838 has(nestedNameSpecifier(
1839 specifiesNamespace(hasName("a")))))));
1840 EXPECT_TRUE(matches(
1841 Fragment,
1842 nestedNameSpecifier(specifiesType(asString("struct a::A")),
1843 has(nestedNameSpecifier(
1844 specifiesNamespace(hasName("a")))))));
1845
1846 // Not really useful because a NestedNameSpecifier can af at most one child,
1847 // but to complete the interface.
1848 EXPECT_TRUE(matchAndVerifyResultTrue(
1849 Fragment,
1850 nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
1851 forEach(nestedNameSpecifier().bind("x"))),
1852 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 1)));
1853 }
1854
TEST(NNS,NestedNameSpecifiersAsDescendants)1855 TEST(NNS, NestedNameSpecifiersAsDescendants) {
1856 std::string Fragment =
1857 "namespace a { struct A { struct B { struct C {}; }; }; };"
1858 "void f() { a::A::B::C c; }";
1859 EXPECT_TRUE(matches(
1860 Fragment,
1861 decl(hasDescendant(nestedNameSpecifier(specifiesType(
1862 asString("struct a::A")))))));
1863 EXPECT_TRUE(matchAndVerifyResultTrue(
1864 Fragment,
1865 functionDecl(hasName("f"),
1866 forEachDescendant(nestedNameSpecifier().bind("x"))),
1867 // Nested names: a, a::A and a::A::B.
1868 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 3)));
1869 }
1870
TEST(NNSLoc,DescendantsOfNestedNameSpecifierLocs)1871 TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
1872 std::string Fragment =
1873 "namespace a { struct A { struct B { struct C {}; }; }; };"
1874 "void f() { a::A::B::C c; }";
1875 EXPECT_TRUE(matches(
1876 Fragment,
1877 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1878 hasDescendant(loc(nestedNameSpecifier(
1879 specifiesNamespace(hasName("a"))))))));
1880 EXPECT_TRUE(notMatches(
1881 Fragment,
1882 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1883 has(loc(nestedNameSpecifier(
1884 specifiesNamespace(hasName("a"))))))));
1885 EXPECT_TRUE(matches(
1886 Fragment,
1887 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
1888 has(loc(nestedNameSpecifier(
1889 specifiesNamespace(hasName("a"))))))));
1890
1891 EXPECT_TRUE(matchAndVerifyResultTrue(
1892 Fragment,
1893 nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
1894 forEach(nestedNameSpecifierLoc().bind("x"))),
1895 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 1)));
1896 }
1897
TEST(NNSLoc,NestedNameSpecifierLocsAsDescendants)1898 TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
1899 std::string Fragment =
1900 "namespace a { struct A { struct B { struct C {}; }; }; };"
1901 "void f() { a::A::B::C c; }";
1902 EXPECT_TRUE(matches(
1903 Fragment,
1904 decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
1905 asString("struct a::A"))))))));
1906 EXPECT_TRUE(matchAndVerifyResultTrue(
1907 Fragment,
1908 functionDecl(hasName("f"),
1909 forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
1910 // Nested names: a, a::A and a::A::B.
1911 llvm::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 3)));
1912 }
1913 template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
1914 public:
VerifyMatchOnNode(StringRef Id,const internal::Matcher<T> & InnerMatcher,StringRef InnerId)1915 VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
1916 StringRef InnerId)
1917 : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
1918 }
1919
run(const BoundNodes * Nodes)1920 bool run(const BoundNodes *Nodes) override { return false; }
1921
run(const BoundNodes * Nodes,ASTContext * Context)1922 bool run(const BoundNodes *Nodes, ASTContext *Context) override {
1923 const T *Node = Nodes->getNodeAs<T>(Id);
1924 return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context)) !=
1925 nullptr;
1926 }
1927 private:
1928 std::string Id;
1929 internal::Matcher<T> InnerMatcher;
1930 std::string InnerId;
1931 };
1932
TEST(MatchFinder,CanMatchDeclarationsRecursively)1933 TEST(MatchFinder, CanMatchDeclarationsRecursively) {
1934 EXPECT_TRUE(matchAndVerifyResultTrue(
1935 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1936 llvm::make_unique<VerifyMatchOnNode<Decl>>(
1937 "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
1938 "Y")));
1939 EXPECT_TRUE(matchAndVerifyResultFalse(
1940 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1941 llvm::make_unique<VerifyMatchOnNode<Decl>>(
1942 "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
1943 "Z")));
1944 }
1945
TEST(MatchFinder,CanMatchStatementsRecursively)1946 TEST(MatchFinder, CanMatchStatementsRecursively) {
1947 EXPECT_TRUE(matchAndVerifyResultTrue(
1948 "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
1949 llvm::make_unique<VerifyMatchOnNode<Stmt>>(
1950 "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
1951 EXPECT_TRUE(matchAndVerifyResultFalse(
1952 "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
1953 llvm::make_unique<VerifyMatchOnNode<Stmt>>(
1954 "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
1955 }
1956
TEST(MatchFinder,CanMatchSingleNodesRecursively)1957 TEST(MatchFinder, CanMatchSingleNodesRecursively) {
1958 EXPECT_TRUE(matchAndVerifyResultTrue(
1959 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1960 llvm::make_unique<VerifyMatchOnNode<Decl>>(
1961 "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
1962 EXPECT_TRUE(matchAndVerifyResultFalse(
1963 "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
1964 llvm::make_unique<VerifyMatchOnNode<Decl>>(
1965 "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
1966 }
1967
TEST(StatementMatcher,HasReturnValue)1968 TEST(StatementMatcher, HasReturnValue) {
1969 StatementMatcher RetVal = returnStmt(hasReturnValue(binaryOperator()));
1970 EXPECT_TRUE(matches("int F() { int a, b; return a + b; }", RetVal));
1971 EXPECT_FALSE(matches("int F() { int a; return a; }", RetVal));
1972 EXPECT_FALSE(matches("void F() { return; }", RetVal));
1973 }
1974
TEST(StatementMatcher,ForFunction)1975 TEST(StatementMatcher, ForFunction) {
1976 const auto CppString1 =
1977 "struct PosVec {"
1978 " PosVec& operator=(const PosVec&) {"
1979 " auto x = [] { return 1; };"
1980 " return *this;"
1981 " }"
1982 "};";
1983 const auto CppString2 =
1984 "void F() {"
1985 " struct S {"
1986 " void F2() {"
1987 " return;"
1988 " }"
1989 " };"
1990 "}";
1991 EXPECT_TRUE(
1992 matches(
1993 CppString1,
1994 returnStmt(forFunction(hasName("operator=")),
1995 has(unaryOperator(hasOperatorName("*"))))));
1996 EXPECT_TRUE(
1997 notMatches(
1998 CppString1,
1999 returnStmt(forFunction(hasName("operator=")),
2000 has(integerLiteral()))));
2001 EXPECT_TRUE(
2002 matches(
2003 CppString1,
2004 returnStmt(forFunction(hasName("operator()")),
2005 has(integerLiteral()))));
2006 EXPECT_TRUE(matches(CppString2, returnStmt(forFunction(hasName("F2")))));
2007 EXPECT_TRUE(notMatches(CppString2, returnStmt(forFunction(hasName("F")))));
2008 }
2009
TEST(Matcher,ForEachOverriden)2010 TEST(Matcher, ForEachOverriden) {
2011 const auto ForEachOverriddenInClass = [](const char *ClassName) {
2012 return cxxMethodDecl(ofClass(hasName(ClassName)), isVirtual(),
2013 forEachOverridden(cxxMethodDecl().bind("overridden")))
2014 .bind("override");
2015 };
2016 static const char Code1[] = "class A { virtual void f(); };"
2017 "class B : public A { void f(); };"
2018 "class C : public B { void f(); };";
2019 // C::f overrides A::f.
2020 EXPECT_TRUE(matchAndVerifyResultTrue(
2021 Code1, ForEachOverriddenInClass("C"),
2022 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2023 EXPECT_TRUE(matchAndVerifyResultTrue(
2024 Code1, ForEachOverriddenInClass("C"),
2025 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2026 1)));
2027 // B::f overrides A::f.
2028 EXPECT_TRUE(matchAndVerifyResultTrue(
2029 Code1, ForEachOverriddenInClass("B"),
2030 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
2031 EXPECT_TRUE(matchAndVerifyResultTrue(
2032 Code1, ForEachOverriddenInClass("B"),
2033 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2034 1)));
2035 // A::f overrides nothing.
2036 EXPECT_TRUE(notMatches(Code1, ForEachOverriddenInClass("A")));
2037
2038 static const char Code2[] =
2039 "class A1 { virtual void f(); };"
2040 "class A2 { virtual void f(); };"
2041 "class B : public A1, public A2 { void f(); };";
2042 // B::f overrides A1::f and A2::f. This produces two matches.
2043 EXPECT_TRUE(matchAndVerifyResultTrue(
2044 Code2, ForEachOverriddenInClass("B"),
2045 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 2)));
2046 EXPECT_TRUE(matchAndVerifyResultTrue(
2047 Code2, ForEachOverriddenInClass("B"),
2048 llvm::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
2049 2)));
2050 // A1::f overrides nothing.
2051 EXPECT_TRUE(notMatches(Code2, ForEachOverriddenInClass("A1")));
2052 }
2053
2054 } // namespace ast_matchers
2055 } // namespace clang
2056