1 //== unittests/ASTMatchers/ASTMatchersNodeTest.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
19 namespace clang {
20 namespace ast_matchers {
21
TEST(Finder,DynamicOnlyAcceptsSomeMatchers)22 TEST(Finder, DynamicOnlyAcceptsSomeMatchers) {
23 MatchFinder Finder;
24 EXPECT_TRUE(Finder.addDynamicMatcher(decl(), nullptr));
25 EXPECT_TRUE(Finder.addDynamicMatcher(callExpr(), nullptr));
26 EXPECT_TRUE(Finder.addDynamicMatcher(constantArrayType(hasSize(42)),
27 nullptr));
28
29 // Do not accept non-toplevel matchers.
30 EXPECT_FALSE(Finder.addDynamicMatcher(isArrow(), nullptr));
31 EXPECT_FALSE(Finder.addDynamicMatcher(hasName("x"), nullptr));
32 }
33
TEST(Decl,MatchesDeclarations)34 TEST(Decl, MatchesDeclarations) {
35 EXPECT_TRUE(notMatches("", decl(usingDecl())));
36 EXPECT_TRUE(matches("namespace x { class X {}; } using x::X;",
37 decl(usingDecl())));
38 }
39
TEST(NameableDeclaration,MatchesVariousDecls)40 TEST(NameableDeclaration, MatchesVariousDecls) {
41 DeclarationMatcher NamedX = namedDecl(hasName("X"));
42 EXPECT_TRUE(matches("typedef int X;", NamedX));
43 EXPECT_TRUE(matches("int X;", NamedX));
44 EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
45 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
46 EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
47 EXPECT_TRUE(matches("namespace X { }", NamedX));
48 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
49
50 EXPECT_TRUE(notMatches("#define X 1", NamedX));
51 }
52
TEST(NameableDeclaration,REMatchesVariousDecls)53 TEST(NameableDeclaration, REMatchesVariousDecls) {
54 DeclarationMatcher NamedX = namedDecl(matchesName("::X"));
55 EXPECT_TRUE(matches("typedef int Xa;", NamedX));
56 EXPECT_TRUE(matches("int Xb;", NamedX));
57 EXPECT_TRUE(matches("class foo { virtual void Xc(); };", NamedX));
58 EXPECT_TRUE(matches("void foo() try { } catch(int Xdef) { }", NamedX));
59 EXPECT_TRUE(matches("void foo() { int Xgh; }", NamedX));
60 EXPECT_TRUE(matches("namespace Xij { }", NamedX));
61 EXPECT_TRUE(matches("enum X { A, B, C };", NamedX));
62
63 EXPECT_TRUE(notMatches("#define Xkl 1", NamedX));
64
65 DeclarationMatcher StartsWithNo = namedDecl(matchesName("::no"));
66 EXPECT_TRUE(matches("int no_foo;", StartsWithNo));
67 EXPECT_TRUE(matches("class foo { virtual void nobody(); };", StartsWithNo));
68
69 DeclarationMatcher Abc = namedDecl(matchesName("a.*b.*c"));
70 EXPECT_TRUE(matches("int abc;", Abc));
71 EXPECT_TRUE(matches("int aFOObBARc;", Abc));
72 EXPECT_TRUE(notMatches("int cab;", Abc));
73 EXPECT_TRUE(matches("int cabc;", Abc));
74
75 DeclarationMatcher StartsWithK = namedDecl(matchesName(":k[^:]*$"));
76 EXPECT_TRUE(matches("int k;", StartsWithK));
77 EXPECT_TRUE(matches("int kAbc;", StartsWithK));
78 EXPECT_TRUE(matches("namespace x { int kTest; }", StartsWithK));
79 EXPECT_TRUE(matches("class C { int k; };", StartsWithK));
80 EXPECT_TRUE(notMatches("class C { int ckc; };", StartsWithK));
81 }
82
TEST(DeclarationMatcher,MatchClass)83 TEST(DeclarationMatcher, MatchClass) {
84 DeclarationMatcher ClassMatcher(recordDecl());
85
86 // This passes on Windows only because we explicitly pass -target
87 // i386-unknown-unknown. If we were to compile with the default target
88 // triple, we'd want to EXPECT_TRUE if it's Win32 or MSVC.
89 EXPECT_FALSE(matches("", ClassMatcher));
90
91 DeclarationMatcher ClassX = recordDecl(recordDecl(hasName("X")));
92 EXPECT_TRUE(matches("class X;", ClassX));
93 EXPECT_TRUE(matches("class X {};", ClassX));
94 EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
95 EXPECT_TRUE(notMatches("", ClassX));
96 }
97
TEST(DeclarationMatcher,translationUnitDecl)98 TEST(DeclarationMatcher, translationUnitDecl) {
99 const std::string Code = "int MyVar1;\n"
100 "namespace NameSpace {\n"
101 "int MyVar2;\n"
102 "} // namespace NameSpace\n";
103 EXPECT_TRUE(matches(
104 Code, varDecl(hasName("MyVar1"), hasDeclContext(translationUnitDecl()))));
105 EXPECT_FALSE(matches(
106 Code, varDecl(hasName("MyVar2"), hasDeclContext(translationUnitDecl()))));
107 EXPECT_TRUE(matches(
108 Code,
109 varDecl(hasName("MyVar2"),
110 hasDeclContext(decl(hasDeclContext(translationUnitDecl()))))));
111 }
112
TEST(DeclarationMatcher,LinkageSpecification)113 TEST(DeclarationMatcher, LinkageSpecification) {
114 EXPECT_TRUE(matches("extern \"C\" { void foo() {}; }", linkageSpecDecl()));
115 EXPECT_TRUE(notMatches("void foo() {};", linkageSpecDecl()));
116 }
117
TEST(ClassTemplate,DoesNotMatchClass)118 TEST(ClassTemplate, DoesNotMatchClass) {
119 DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
120 EXPECT_TRUE(notMatches("class X;", ClassX));
121 EXPECT_TRUE(notMatches("class X {};", ClassX));
122 }
123
TEST(ClassTemplate,MatchesClassTemplate)124 TEST(ClassTemplate, MatchesClassTemplate) {
125 DeclarationMatcher ClassX = classTemplateDecl(hasName("X"));
126 EXPECT_TRUE(matches("template<typename T> class X {};", ClassX));
127 EXPECT_TRUE(matches("class Z { template<class T> class X {}; };", ClassX));
128 }
129
TEST(ClassTemplate,DoesNotMatchClassTemplateExplicitSpecialization)130 TEST(ClassTemplate, DoesNotMatchClassTemplateExplicitSpecialization) {
131 EXPECT_TRUE(notMatches("template<typename T> class X { };"
132 "template<> class X<int> { int a; };",
133 classTemplateDecl(hasName("X"),
134 hasDescendant(fieldDecl(hasName("a"))))));
135 }
136
TEST(ClassTemplate,DoesNotMatchClassTemplatePartialSpecialization)137 TEST(ClassTemplate, DoesNotMatchClassTemplatePartialSpecialization) {
138 EXPECT_TRUE(notMatches("template<typename T, typename U> class X { };"
139 "template<typename T> class X<T, int> { int a; };",
140 classTemplateDecl(hasName("X"),
141 hasDescendant(fieldDecl(hasName("a"))))));
142 }
143
TEST(DeclarationMatcher,MatchCudaDecl)144 TEST(DeclarationMatcher, MatchCudaDecl) {
145 EXPECT_TRUE(matchesWithCuda("__global__ void f() { }"
146 "void g() { f<<<1, 2>>>(); }",
147 cudaKernelCallExpr()));
148 EXPECT_TRUE(matchesWithCuda("__attribute__((device)) void f() {}",
149 hasAttr(clang::attr::CUDADevice)));
150 EXPECT_TRUE(notMatchesWithCuda("void f() {}",
151 cudaKernelCallExpr()));
152 EXPECT_FALSE(notMatchesWithCuda("__attribute__((global)) void f() {}",
153 hasAttr(clang::attr::CUDAGlobal)));
154 }
155
TEST(ValueDecl,Matches)156 TEST(ValueDecl, Matches) {
157 EXPECT_TRUE(matches("enum EnumType { EnumValue };",
158 valueDecl(hasType(asString("enum EnumType")))));
159 EXPECT_TRUE(matches("void FunctionDecl();",
160 valueDecl(hasType(asString("void (void)")))));
161 }
162
TEST(Enum,DoesNotMatchClasses)163 TEST(Enum, DoesNotMatchClasses) {
164 EXPECT_TRUE(notMatches("class X {};", enumDecl(hasName("X"))));
165 }
166
TEST(Enum,MatchesEnums)167 TEST(Enum, MatchesEnums) {
168 EXPECT_TRUE(matches("enum X {};", enumDecl(hasName("X"))));
169 }
170
TEST(EnumConstant,Matches)171 TEST(EnumConstant, Matches) {
172 DeclarationMatcher Matcher = enumConstantDecl(hasName("A"));
173 EXPECT_TRUE(matches("enum X{ A };", Matcher));
174 EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
175 EXPECT_TRUE(notMatches("enum X {};", Matcher));
176 }
177
TEST(Matcher,UnresolvedLookupExpr)178 TEST(Matcher, UnresolvedLookupExpr) {
179 // FIXME: The test is known to be broken on Windows with delayed template
180 // parsing.
181 EXPECT_TRUE(matchesConditionally("template<typename T>"
182 "T foo() { T a; return a; }"
183 "template<typename T>"
184 "void bar() {"
185 " foo<T>();"
186 "}",
187 unresolvedLookupExpr(),
188 /*ExpectMatch=*/true,
189 "-fno-delayed-template-parsing"));
190 }
191
TEST(Matcher,Call)192 TEST(Matcher, Call) {
193 // FIXME: Do we want to overload Call() to directly take
194 // Matcher<Decl>, too?
195 StatementMatcher MethodX =
196 callExpr(hasDeclaration(cxxMethodDecl(hasName("x"))));
197
198 EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
199 EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
200
201 StatementMatcher MethodOnY =
202 cxxMemberCallExpr(on(hasType(recordDecl(hasName("Y")))));
203
204 EXPECT_TRUE(
205 matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
206 MethodOnY));
207 EXPECT_TRUE(
208 matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
209 MethodOnY));
210 EXPECT_TRUE(
211 notMatches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
212 MethodOnY));
213 EXPECT_TRUE(
214 notMatches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
215 MethodOnY));
216 EXPECT_TRUE(
217 notMatches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
218 MethodOnY));
219
220 StatementMatcher MethodOnYPointer =
221 cxxMemberCallExpr(on(hasType(pointsTo(recordDecl(hasName("Y"))))));
222
223 EXPECT_TRUE(
224 matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
225 MethodOnYPointer));
226 EXPECT_TRUE(
227 matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
228 MethodOnYPointer));
229 EXPECT_TRUE(
230 matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
231 MethodOnYPointer));
232 EXPECT_TRUE(
233 notMatches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
234 MethodOnYPointer));
235 EXPECT_TRUE(
236 notMatches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
237 MethodOnYPointer));
238 }
TEST(Matcher,Lambda)239 TEST(Matcher, Lambda) {
240 EXPECT_TRUE(matches("auto f = [] (int i) { return i; };",
241 lambdaExpr()));
242 }
243
TEST(Matcher,ForRange)244 TEST(Matcher, ForRange) {
245 EXPECT_TRUE(matches("int as[] = { 1, 2, 3 };"
246 "void f() { for (auto &a : as); }",
247 cxxForRangeStmt()));
248 EXPECT_TRUE(notMatches("void f() { for (int i; i<5; ++i); }",
249 cxxForRangeStmt()));
250 }
251
TEST(Matcher,SubstNonTypeTemplateParm)252 TEST(Matcher, SubstNonTypeTemplateParm) {
253 EXPECT_FALSE(matches("template<int N>\n"
254 "struct A { static const int n = 0; };\n"
255 "struct B : public A<42> {};",
256 substNonTypeTemplateParmExpr()));
257 EXPECT_TRUE(matches("template<int N>\n"
258 "struct A { static const int n = N; };\n"
259 "struct B : public A<42> {};",
260 substNonTypeTemplateParmExpr()));
261 }
262
TEST(Matcher,NonTypeTemplateParmDecl)263 TEST(Matcher, NonTypeTemplateParmDecl) {
264 EXPECT_TRUE(matches("template <int N> void f();",
265 nonTypeTemplateParmDecl(hasName("N"))));
266 EXPECT_TRUE(
267 notMatches("template <typename T> void f();", nonTypeTemplateParmDecl()));
268 }
269
TEST(Matcher,templateTypeParmDecl)270 TEST(Matcher, templateTypeParmDecl) {
271 EXPECT_TRUE(matches("template <typename T> void f();",
272 templateTypeParmDecl(hasName("T"))));
273 EXPECT_TRUE(
274 notMatches("template <int N> void f();", templateTypeParmDecl()));
275 }
276
TEST(Matcher,UserDefinedLiteral)277 TEST(Matcher, UserDefinedLiteral) {
278 EXPECT_TRUE(matches("constexpr char operator \"\" _inc (const char i) {"
279 " return i + 1;"
280 "}"
281 "char c = 'a'_inc;",
282 userDefinedLiteral()));
283 }
284
TEST(Matcher,FlowControl)285 TEST(Matcher, FlowControl) {
286 EXPECT_TRUE(matches("void f() { while(true) { break; } }", breakStmt()));
287 EXPECT_TRUE(matches("void f() { while(true) { continue; } }",
288 continueStmt()));
289 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}", gotoStmt()));
290 EXPECT_TRUE(matches("void f() { goto FOO; FOO: ;}",
291 labelStmt(
292 hasDeclaration(
293 labelDecl(hasName("FOO"))))));
294 EXPECT_TRUE(matches("void f() { FOO: ; void *ptr = &&FOO; goto *ptr; }",
295 addrLabelExpr()));
296 EXPECT_TRUE(matches("void f() { return; }", returnStmt()));
297 }
298
TEST(Matcher,OverloadedOperatorCall)299 TEST(Matcher, OverloadedOperatorCall) {
300 StatementMatcher OpCall = cxxOperatorCallExpr();
301 // Unary operator
302 EXPECT_TRUE(matches("class Y { }; "
303 "bool operator!(Y x) { return false; }; "
304 "Y y; bool c = !y;", OpCall));
305 // No match -- special operators like "new", "delete"
306 // FIXME: operator new takes size_t, for which we need stddef.h, for which
307 // we need to figure out include paths in the test.
308 // EXPECT_TRUE(NotMatches("#include <stddef.h>\n"
309 // "class Y { }; "
310 // "void *operator new(size_t size) { return 0; } "
311 // "Y *y = new Y;", OpCall));
312 EXPECT_TRUE(notMatches("class Y { }; "
313 "void operator delete(void *p) { } "
314 "void a() {Y *y = new Y; delete y;}", OpCall));
315 // Binary operator
316 EXPECT_TRUE(matches("class Y { }; "
317 "bool operator&&(Y x, Y y) { return true; }; "
318 "Y a; Y b; bool c = a && b;",
319 OpCall));
320 // No match -- normal operator, not an overloaded one.
321 EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
322 EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
323 }
324
TEST(Matcher,ThisPointerType)325 TEST(Matcher, ThisPointerType) {
326 StatementMatcher MethodOnY =
327 cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y"))));
328
329 EXPECT_TRUE(
330 matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
331 MethodOnY));
332 EXPECT_TRUE(
333 matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
334 MethodOnY));
335 EXPECT_TRUE(
336 matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
337 MethodOnY));
338 EXPECT_TRUE(
339 matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
340 MethodOnY));
341 EXPECT_TRUE(
342 matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
343 MethodOnY));
344
345 EXPECT_TRUE(matches(
346 "class Y {"
347 " public: virtual void x();"
348 "};"
349 "class X : public Y {"
350 " public: virtual void x();"
351 "};"
352 "void z() { X *x; x->Y::x(); }", MethodOnY));
353 }
354
TEST(Matcher,VariableUsage)355 TEST(Matcher, VariableUsage) {
356 StatementMatcher Reference =
357 declRefExpr(to(
358 varDecl(hasInitializer(
359 cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y"))))))));
360
361 EXPECT_TRUE(matches(
362 "class Y {"
363 " public:"
364 " bool x() const;"
365 "};"
366 "void z(const Y &y) {"
367 " bool b = y.x();"
368 " if (b) {}"
369 "}", Reference));
370
371 EXPECT_TRUE(notMatches(
372 "class Y {"
373 " public:"
374 " bool x() const;"
375 "};"
376 "void z(const Y &y) {"
377 " bool b = y.x();"
378 "}", Reference));
379 }
380
TEST(Matcher,CalledVariable)381 TEST(Matcher, CalledVariable) {
382 StatementMatcher CallOnVariableY =
383 cxxMemberCallExpr(on(declRefExpr(to(varDecl(hasName("y"))))));
384
385 EXPECT_TRUE(matches(
386 "class Y { public: void x() { Y y; y.x(); } };", CallOnVariableY));
387 EXPECT_TRUE(matches(
388 "class Y { public: void x() const { Y y; y.x(); } };", CallOnVariableY));
389 EXPECT_TRUE(matches(
390 "class Y { public: void x(); };"
391 "class X : public Y { void z() { X y; y.x(); } };", CallOnVariableY));
392 EXPECT_TRUE(matches(
393 "class Y { public: void x(); };"
394 "class X : public Y { void z() { X *y; y->x(); } };", CallOnVariableY));
395 EXPECT_TRUE(notMatches(
396 "class Y { public: void x(); };"
397 "class X : public Y { void z() { unsigned long y; ((X*)y)->x(); } };",
398 CallOnVariableY));
399 }
400
TEST(UnaryExprOrTypeTraitExpr,MatchesSizeOfAndAlignOf)401 TEST(UnaryExprOrTypeTraitExpr, MatchesSizeOfAndAlignOf) {
402 EXPECT_TRUE(matches("void x() { int a = sizeof(a); }",
403 unaryExprOrTypeTraitExpr()));
404 EXPECT_TRUE(notMatches("void x() { int a = sizeof(a); }",
405 alignOfExpr(anything())));
406 // FIXME: Uncomment once alignof is enabled.
407 // EXPECT_TRUE(matches("void x() { int a = alignof(a); }",
408 // unaryExprOrTypeTraitExpr()));
409 // EXPECT_TRUE(notMatches("void x() { int a = alignof(a); }",
410 // sizeOfExpr()));
411 }
412
TEST(MemberExpression,DoesNotMatchClasses)413 TEST(MemberExpression, DoesNotMatchClasses) {
414 EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpr()));
415 }
416
TEST(MemberExpression,MatchesMemberFunctionCall)417 TEST(MemberExpression, MatchesMemberFunctionCall) {
418 EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpr()));
419 }
420
TEST(MemberExpression,MatchesVariable)421 TEST(MemberExpression, MatchesVariable) {
422 EXPECT_TRUE(
423 matches("class Y { void x() { this->y; } int y; };", memberExpr()));
424 EXPECT_TRUE(
425 matches("class Y { void x() { y; } int y; };", memberExpr()));
426 EXPECT_TRUE(
427 matches("class Y { void x() { Y y; y.y; } int y; };", memberExpr()));
428 }
429
TEST(MemberExpression,MatchesStaticVariable)430 TEST(MemberExpression, MatchesStaticVariable) {
431 EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
432 memberExpr()));
433 EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
434 memberExpr()));
435 EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
436 memberExpr()));
437 }
438
TEST(Function,MatchesFunctionDeclarations)439 TEST(Function, MatchesFunctionDeclarations) {
440 StatementMatcher CallFunctionF = callExpr(callee(functionDecl(hasName("f"))));
441
442 EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
443 EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
444
445 if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
446 llvm::Triple::Win32) {
447 // FIXME: Make this work for MSVC.
448 // Dependent contexts, but a non-dependent call.
449 EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
450 CallFunctionF));
451 EXPECT_TRUE(
452 matches("void f(); template <int N> struct S { void g() { f(); } };",
453 CallFunctionF));
454 }
455
456 // Depedent calls don't match.
457 EXPECT_TRUE(
458 notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
459 CallFunctionF));
460 EXPECT_TRUE(
461 notMatches("void f(int);"
462 "template <typename T> struct S { void g(T t) { f(t); } };",
463 CallFunctionF));
464
465 EXPECT_TRUE(matches("void f(...);", functionDecl(isVariadic())));
466 EXPECT_TRUE(notMatches("void f(int);", functionDecl(isVariadic())));
467 EXPECT_TRUE(notMatches("template <typename... Ts> void f(Ts...);",
468 functionDecl(isVariadic())));
469 EXPECT_TRUE(notMatches("void f();", functionDecl(isVariadic())));
470 EXPECT_TRUE(notMatchesC("void f();", functionDecl(isVariadic())));
471 EXPECT_TRUE(matches("void f(...);", functionDecl(parameterCountIs(0))));
472 EXPECT_TRUE(matchesC("void f();", functionDecl(parameterCountIs(0))));
473 EXPECT_TRUE(matches("void f(int, ...);", functionDecl(parameterCountIs(1))));
474 }
475
TEST(FunctionTemplate,MatchesFunctionTemplateDeclarations)476 TEST(FunctionTemplate, MatchesFunctionTemplateDeclarations) {
477 EXPECT_TRUE(
478 matches("template <typename T> void f(T t) {}",
479 functionTemplateDecl(hasName("f"))));
480 }
481
TEST(FunctionTemplate,DoesNotMatchFunctionDeclarations)482 TEST(FunctionTemplate, DoesNotMatchFunctionDeclarations) {
483 EXPECT_TRUE(
484 notMatches("void f(double d); void f(int t) {}",
485 functionTemplateDecl(hasName("f"))));
486 }
487
TEST(FunctionTemplate,DoesNotMatchFunctionTemplateSpecializations)488 TEST(FunctionTemplate, DoesNotMatchFunctionTemplateSpecializations) {
489 EXPECT_TRUE(
490 notMatches("void g(); template <typename T> void f(T t) {}"
491 "template <> void f(int t) { g(); }",
492 functionTemplateDecl(hasName("f"),
493 hasDescendant(declRefExpr(to(
494 functionDecl(hasName("g"))))))));
495 }
496
TEST(Matcher,MatchesClassTemplateSpecialization)497 TEST(Matcher, MatchesClassTemplateSpecialization) {
498 EXPECT_TRUE(matches("template<typename T> struct A {};"
499 "template<> struct A<int> {};",
500 classTemplateSpecializationDecl()));
501 EXPECT_TRUE(matches("template<typename T> struct A {}; A<int> a;",
502 classTemplateSpecializationDecl()));
503 EXPECT_TRUE(notMatches("template<typename T> struct A {};",
504 classTemplateSpecializationDecl()));
505 }
506
TEST(DeclaratorDecl,MatchesDeclaratorDecls)507 TEST(DeclaratorDecl, MatchesDeclaratorDecls) {
508 EXPECT_TRUE(matches("int x;", declaratorDecl()));
509 EXPECT_TRUE(notMatches("class A {};", declaratorDecl()));
510 }
511
TEST(ParmVarDecl,MatchesParmVars)512 TEST(ParmVarDecl, MatchesParmVars) {
513 EXPECT_TRUE(matches("void f(int x);", parmVarDecl()));
514 EXPECT_TRUE(notMatches("void f();", parmVarDecl()));
515 }
516
TEST(Matcher,ConstructorCall)517 TEST(Matcher, ConstructorCall) {
518 StatementMatcher Constructor = cxxConstructExpr();
519
520 EXPECT_TRUE(
521 matches("class X { public: X(); }; void x() { X x; }", Constructor));
522 EXPECT_TRUE(
523 matches("class X { public: X(); }; void x() { X x = X(); }",
524 Constructor));
525 EXPECT_TRUE(
526 matches("class X { public: X(int); }; void x() { X x = 0; }",
527 Constructor));
528 EXPECT_TRUE(matches("class X {}; void x(int) { X x; }", Constructor));
529 }
530
TEST(Matcher,ThisExpr)531 TEST(Matcher, ThisExpr) {
532 EXPECT_TRUE(
533 matches("struct X { int a; int f () { return a; } };", cxxThisExpr()));
534 EXPECT_TRUE(
535 notMatches("struct X { int f () { int a; return a; } };", cxxThisExpr()));
536 }
537
TEST(Matcher,BindTemporaryExpression)538 TEST(Matcher, BindTemporaryExpression) {
539 StatementMatcher TempExpression = cxxBindTemporaryExpr();
540
541 std::string ClassString = "class string { public: string(); ~string(); }; ";
542
543 EXPECT_TRUE(
544 matches(ClassString +
545 "string GetStringByValue();"
546 "void FunctionTakesString(string s);"
547 "void run() { FunctionTakesString(GetStringByValue()); }",
548 TempExpression));
549
550 EXPECT_TRUE(
551 notMatches(ClassString +
552 "string* GetStringPointer(); "
553 "void FunctionTakesStringPtr(string* s);"
554 "void run() {"
555 " string* s = GetStringPointer();"
556 " FunctionTakesStringPtr(GetStringPointer());"
557 " FunctionTakesStringPtr(s);"
558 "}",
559 TempExpression));
560
561 EXPECT_TRUE(
562 notMatches("class no_dtor {};"
563 "no_dtor GetObjByValue();"
564 "void ConsumeObj(no_dtor param);"
565 "void run() { ConsumeObj(GetObjByValue()); }",
566 TempExpression));
567 }
568
TEST(MaterializeTemporaryExpr,MatchesTemporary)569 TEST(MaterializeTemporaryExpr, MatchesTemporary) {
570 std::string ClassString =
571 "class string { public: string(); int length(); }; ";
572
573 EXPECT_TRUE(
574 matches(ClassString +
575 "string GetStringByValue();"
576 "void FunctionTakesString(string s);"
577 "void run() { FunctionTakesString(GetStringByValue()); }",
578 materializeTemporaryExpr()));
579
580 EXPECT_TRUE(
581 notMatches(ClassString +
582 "string* GetStringPointer(); "
583 "void FunctionTakesStringPtr(string* s);"
584 "void run() {"
585 " string* s = GetStringPointer();"
586 " FunctionTakesStringPtr(GetStringPointer());"
587 " FunctionTakesStringPtr(s);"
588 "}",
589 materializeTemporaryExpr()));
590
591 EXPECT_TRUE(
592 notMatches(ClassString +
593 "string GetStringByValue();"
594 "void run() { int k = GetStringByValue().length(); }",
595 materializeTemporaryExpr()));
596
597 EXPECT_TRUE(
598 notMatches(ClassString +
599 "string GetStringByValue();"
600 "void run() { GetStringByValue(); }",
601 materializeTemporaryExpr()));
602 }
603
TEST(Matcher,NewExpression)604 TEST(Matcher, NewExpression) {
605 StatementMatcher New = cxxNewExpr();
606
607 EXPECT_TRUE(matches("class X { public: X(); }; void x() { new X; }", New));
608 EXPECT_TRUE(
609 matches("class X { public: X(); }; void x() { new X(); }", New));
610 EXPECT_TRUE(
611 matches("class X { public: X(int); }; void x() { new X(0); }", New));
612 EXPECT_TRUE(matches("class X {}; void x(int) { new X; }", New));
613 }
614
TEST(Matcher,DeleteExpression)615 TEST(Matcher, DeleteExpression) {
616 EXPECT_TRUE(matches("struct A {}; void f(A* a) { delete a; }",
617 cxxDeleteExpr()));
618 }
619
TEST(Matcher,DefaultArgument)620 TEST(Matcher, DefaultArgument) {
621 StatementMatcher Arg = cxxDefaultArgExpr();
622
623 EXPECT_TRUE(matches("void x(int, int = 0) { int y; x(y); }", Arg));
624 EXPECT_TRUE(
625 matches("class X { void x(int, int = 0) { int y; x(y); } };", Arg));
626 EXPECT_TRUE(notMatches("void x(int, int = 0) { int y; x(y, 0); }", Arg));
627 }
628
TEST(Matcher,StringLiterals)629 TEST(Matcher, StringLiterals) {
630 StatementMatcher Literal = stringLiteral();
631 EXPECT_TRUE(matches("const char *s = \"string\";", Literal));
632 // wide string
633 EXPECT_TRUE(matches("const wchar_t *s = L\"string\";", Literal));
634 // with escaped characters
635 EXPECT_TRUE(matches("const char *s = \"\x05five\";", Literal));
636 // no matching -- though the data type is the same, there is no string literal
637 EXPECT_TRUE(notMatches("const char s[1] = {'a'};", Literal));
638 }
639
TEST(Matcher,CharacterLiterals)640 TEST(Matcher, CharacterLiterals) {
641 StatementMatcher CharLiteral = characterLiteral();
642 EXPECT_TRUE(matches("const char c = 'c';", CharLiteral));
643 // wide character
644 EXPECT_TRUE(matches("const char c = L'c';", CharLiteral));
645 // wide character, Hex encoded, NOT MATCHED!
646 EXPECT_TRUE(notMatches("const wchar_t c = 0x2126;", CharLiteral));
647 EXPECT_TRUE(notMatches("const char c = 0x1;", CharLiteral));
648 }
649
TEST(Matcher,IntegerLiterals)650 TEST(Matcher, IntegerLiterals) {
651 StatementMatcher HasIntLiteral = integerLiteral();
652 EXPECT_TRUE(matches("int i = 10;", HasIntLiteral));
653 EXPECT_TRUE(matches("int i = 0x1AB;", HasIntLiteral));
654 EXPECT_TRUE(matches("int i = 10L;", HasIntLiteral));
655 EXPECT_TRUE(matches("int i = 10U;", HasIntLiteral));
656
657 // Non-matching cases (character literals, float and double)
658 EXPECT_TRUE(notMatches("int i = L'a';",
659 HasIntLiteral)); // this is actually a character
660 // literal cast to int
661 EXPECT_TRUE(notMatches("int i = 'a';", HasIntLiteral));
662 EXPECT_TRUE(notMatches("int i = 1e10;", HasIntLiteral));
663 EXPECT_TRUE(notMatches("int i = 10.0;", HasIntLiteral));
664 }
665
TEST(Matcher,FloatLiterals)666 TEST(Matcher, FloatLiterals) {
667 StatementMatcher HasFloatLiteral = floatLiteral();
668 EXPECT_TRUE(matches("float i = 10.0;", HasFloatLiteral));
669 EXPECT_TRUE(matches("float i = 10.0f;", HasFloatLiteral));
670 EXPECT_TRUE(matches("double i = 10.0;", HasFloatLiteral));
671 EXPECT_TRUE(matches("double i = 10.0L;", HasFloatLiteral));
672 EXPECT_TRUE(matches("double i = 1e10;", HasFloatLiteral));
673 EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0))));
674 EXPECT_TRUE(matches("double i = 5.0;", floatLiteral(equals(5.0f))));
675 EXPECT_TRUE(
676 matches("double i = 5.0;", floatLiteral(equals(llvm::APFloat(5.0)))));
677
678 EXPECT_TRUE(notMatches("float i = 10;", HasFloatLiteral));
679 EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0))));
680 EXPECT_TRUE(notMatches("double i = 5.0;", floatLiteral(equals(6.0f))));
681 EXPECT_TRUE(
682 notMatches("double i = 5.0;", floatLiteral(equals(llvm::APFloat(6.0)))));
683 }
684
TEST(Matcher,NullPtrLiteral)685 TEST(Matcher, NullPtrLiteral) {
686 EXPECT_TRUE(matches("int* i = nullptr;", cxxNullPtrLiteralExpr()));
687 }
688
TEST(Matcher,GNUNullExpr)689 TEST(Matcher, GNUNullExpr) {
690 EXPECT_TRUE(matches("int* i = __null;", gnuNullExpr()));
691 }
692
TEST(Matcher,AtomicExpr)693 TEST(Matcher, AtomicExpr) {
694 EXPECT_TRUE(matches("void foo() { int *ptr; __atomic_load_n(ptr, 1); }",
695 atomicExpr()));
696 }
697
TEST(Matcher,Initializers)698 TEST(Matcher, Initializers) {
699 const char *ToMatch = "void foo() { struct point { double x; double y; };"
700 " struct point ptarray[10] = "
701 " { [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }";
702 EXPECT_TRUE(matchesConditionally(
703 ToMatch,
704 initListExpr(
705 has(
706 cxxConstructExpr(
707 requiresZeroInitialization())),
708 has(
709 initListExpr(
710 hasType(asString("struct point")),
711 has(floatLiteral(equals(1.0))),
712 has(implicitValueInitExpr(
713 hasType(asString("double")))))),
714 has(
715 initListExpr(
716 hasType(asString("struct point")),
717 has(floatLiteral(equals(2.0))),
718 has(floatLiteral(equals(1.0)))))
719 ), true, "-std=gnu++98"));
720
721 EXPECT_TRUE(matchesC99(ToMatch,
722 initListExpr(
723 hasSyntacticForm(
724 initListExpr(
725 has(
726 designatedInitExpr(
727 designatorCountIs(2),
728 has(floatLiteral(
729 equals(1.0))),
730 has(integerLiteral(
731 equals(2))))),
732 has(
733 designatedInitExpr(
734 designatorCountIs(2),
735 has(floatLiteral(
736 equals(2.0))),
737 has(integerLiteral(
738 equals(2))))),
739 has(
740 designatedInitExpr(
741 designatorCountIs(2),
742 has(floatLiteral(
743 equals(1.0))),
744 has(integerLiteral(
745 equals(0)))))
746 )))));
747 }
748
TEST(Matcher,ParenListExpr)749 TEST(Matcher, ParenListExpr) {
750 EXPECT_TRUE(
751 matches("template<typename T> class foo { void bar() { foo X(*this); } };"
752 "template class foo<int>;",
753 varDecl(hasInitializer(parenListExpr(has(unaryOperator()))))));
754 }
755
TEST(Matcher,StmtExpr)756 TEST(Matcher, StmtExpr) {
757 EXPECT_TRUE(matches("void declToImport() { int C = ({int X=4; X;}); }",
758 varDecl(hasInitializer(stmtExpr()))));
759 }
760
TEST(Matcher,ImportPredefinedExpr)761 TEST(Matcher, ImportPredefinedExpr) {
762 // __func__ expands as StringLiteral("foo")
763 EXPECT_TRUE(matches("void foo() { __func__; }",
764 predefinedExpr(
765 hasType(asString("const char [4]")),
766 has(stringLiteral()))));
767 }
768
TEST(Matcher,AsmStatement)769 TEST(Matcher, AsmStatement) {
770 EXPECT_TRUE(matches("void foo() { __asm(\"mov al, 2\"); }", asmStmt()));
771 }
772
TEST(Matcher,Conditions)773 TEST(Matcher, Conditions) {
774 StatementMatcher Condition =
775 ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
776
777 EXPECT_TRUE(matches("void x() { if (true) {} }", Condition));
778 EXPECT_TRUE(notMatches("void x() { if (false) {} }", Condition));
779 EXPECT_TRUE(notMatches("void x() { bool a = true; if (a) {} }", Condition));
780 EXPECT_TRUE(notMatches("void x() { if (true || false) {} }", Condition));
781 EXPECT_TRUE(notMatches("void x() { if (1) {} }", Condition));
782 }
783
TEST(Matcher,ConditionalOperator)784 TEST(Matcher, ConditionalOperator) {
785 StatementMatcher Conditional = conditionalOperator(
786 hasCondition(cxxBoolLiteral(equals(true))),
787 hasTrueExpression(cxxBoolLiteral(equals(false))));
788
789 EXPECT_TRUE(matches("void x() { true ? false : true; }", Conditional));
790 EXPECT_TRUE(notMatches("void x() { false ? false : true; }", Conditional));
791 EXPECT_TRUE(notMatches("void x() { true ? true : false; }", Conditional));
792
793 StatementMatcher ConditionalFalse = conditionalOperator(
794 hasFalseExpression(cxxBoolLiteral(equals(false))));
795
796 EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
797 EXPECT_TRUE(
798 notMatches("void x() { true ? false : true; }", ConditionalFalse));
799
800 EXPECT_TRUE(matches("void x() { true ? true : false; }", ConditionalFalse));
801 EXPECT_TRUE(
802 notMatches("void x() { true ? false : true; }", ConditionalFalse));
803 }
804
TEST(Matcher,BinaryConditionalOperator)805 TEST(Matcher, BinaryConditionalOperator) {
806 StatementMatcher AlwaysOne = binaryConditionalOperator(
807 hasCondition(implicitCastExpr(
808 has(
809 opaqueValueExpr(
810 hasSourceExpression((integerLiteral(equals(1)))))))),
811 hasFalseExpression(integerLiteral(equals(0))));
812
813 EXPECT_TRUE(matches("void x() { 1 ?: 0; }", AlwaysOne));
814
815 StatementMatcher FourNotFive = binaryConditionalOperator(
816 hasTrueExpression(opaqueValueExpr(
817 hasSourceExpression((integerLiteral(equals(4)))))),
818 hasFalseExpression(integerLiteral(equals(5))));
819
820 EXPECT_TRUE(matches("void x() { 4 ?: 5; }", FourNotFive));
821 }
822
TEST(ArraySubscriptMatchers,ArraySubscripts)823 TEST(ArraySubscriptMatchers, ArraySubscripts) {
824 EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 1; }",
825 arraySubscriptExpr()));
826 EXPECT_TRUE(notMatches("int i; void f() { i = 1; }",
827 arraySubscriptExpr()));
828 }
829
TEST(For,FindsForLoops)830 TEST(For, FindsForLoops) {
831 EXPECT_TRUE(matches("void f() { for(;;); }", forStmt()));
832 EXPECT_TRUE(matches("void f() { if(true) for(;;); }", forStmt()));
833 EXPECT_TRUE(notMatches("int as[] = { 1, 2, 3 };"
834 "void f() { for (auto &a : as); }",
835 forStmt()));
836 }
837
TEST(For,ReportsNoFalsePositives)838 TEST(For, ReportsNoFalsePositives) {
839 EXPECT_TRUE(notMatches("void f() { ; }", forStmt()));
840 EXPECT_TRUE(notMatches("void f() { if(true); }", forStmt()));
841 }
842
TEST(CompoundStatement,HandlesSimpleCases)843 TEST(CompoundStatement, HandlesSimpleCases) {
844 EXPECT_TRUE(notMatches("void f();", compoundStmt()));
845 EXPECT_TRUE(matches("void f() {}", compoundStmt()));
846 EXPECT_TRUE(matches("void f() {{}}", compoundStmt()));
847 }
848
TEST(CompoundStatement,DoesNotMatchEmptyStruct)849 TEST(CompoundStatement, DoesNotMatchEmptyStruct) {
850 // It's not a compound statement just because there's "{}" in the source
851 // text. This is an AST search, not grep.
852 EXPECT_TRUE(notMatches("namespace n { struct S {}; }",
853 compoundStmt()));
854 EXPECT_TRUE(matches("namespace n { struct S { void f() {{}} }; }",
855 compoundStmt()));
856 }
857
TEST(CastExpression,MatchesExplicitCasts)858 TEST(CastExpression, MatchesExplicitCasts) {
859 EXPECT_TRUE(matches("char *p = reinterpret_cast<char *>(&p);",castExpr()));
860 EXPECT_TRUE(matches("void *p = (void *)(&p);", castExpr()));
861 EXPECT_TRUE(matches("char q, *p = const_cast<char *>(&q);", castExpr()));
862 EXPECT_TRUE(matches("char c = char(0);", castExpr()));
863 }
TEST(CastExpression,MatchesImplicitCasts)864 TEST(CastExpression, MatchesImplicitCasts) {
865 // This test creates an implicit cast from int to char.
866 EXPECT_TRUE(matches("char c = 0;", castExpr()));
867 // This test creates an implicit cast from lvalue to rvalue.
868 EXPECT_TRUE(matches("char c = 0, d = c;", castExpr()));
869 }
870
TEST(CastExpression,DoesNotMatchNonCasts)871 TEST(CastExpression, DoesNotMatchNonCasts) {
872 EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
873 EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
874 EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
875 EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
876 }
877
TEST(ReinterpretCast,MatchesSimpleCase)878 TEST(ReinterpretCast, MatchesSimpleCase) {
879 EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
880 cxxReinterpretCastExpr()));
881 }
882
TEST(ReinterpretCast,DoesNotMatchOtherCasts)883 TEST(ReinterpretCast, DoesNotMatchOtherCasts) {
884 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxReinterpretCastExpr()));
885 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
886 cxxReinterpretCastExpr()));
887 EXPECT_TRUE(notMatches("void* p = static_cast<void*>(&p);",
888 cxxReinterpretCastExpr()));
889 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
890 "B b;"
891 "D* p = dynamic_cast<D*>(&b);",
892 cxxReinterpretCastExpr()));
893 }
894
TEST(FunctionalCast,MatchesSimpleCase)895 TEST(FunctionalCast, MatchesSimpleCase) {
896 std::string foo_class = "class Foo { public: Foo(const char*); };";
897 EXPECT_TRUE(matches(foo_class + "void r() { Foo f = Foo(\"hello world\"); }",
898 cxxFunctionalCastExpr()));
899 }
900
TEST(FunctionalCast,DoesNotMatchOtherCasts)901 TEST(FunctionalCast, DoesNotMatchOtherCasts) {
902 std::string FooClass = "class Foo { public: Foo(const char*); };";
903 EXPECT_TRUE(
904 notMatches(FooClass + "void r() { Foo f = (Foo) \"hello world\"; }",
905 cxxFunctionalCastExpr()));
906 EXPECT_TRUE(
907 notMatches(FooClass + "void r() { Foo f = \"hello world\"; }",
908 cxxFunctionalCastExpr()));
909 }
910
TEST(DynamicCast,MatchesSimpleCase)911 TEST(DynamicCast, MatchesSimpleCase) {
912 EXPECT_TRUE(matches("struct B { virtual ~B() {} }; struct D : B {};"
913 "B b;"
914 "D* p = dynamic_cast<D*>(&b);",
915 cxxDynamicCastExpr()));
916 }
917
TEST(StaticCast,MatchesSimpleCase)918 TEST(StaticCast, MatchesSimpleCase) {
919 EXPECT_TRUE(matches("void* p(static_cast<void*>(&p));",
920 cxxStaticCastExpr()));
921 }
922
TEST(StaticCast,DoesNotMatchOtherCasts)923 TEST(StaticCast, DoesNotMatchOtherCasts) {
924 EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxStaticCastExpr()));
925 EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",
926 cxxStaticCastExpr()));
927 EXPECT_TRUE(notMatches("void* p = reinterpret_cast<char*>(&p);",
928 cxxStaticCastExpr()));
929 EXPECT_TRUE(notMatches("struct B { virtual ~B() {} }; struct D : B {};"
930 "B b;"
931 "D* p = dynamic_cast<D*>(&b);",
932 cxxStaticCastExpr()));
933 }
934
TEST(CStyleCast,MatchesSimpleCase)935 TEST(CStyleCast, MatchesSimpleCase) {
936 EXPECT_TRUE(matches("int i = (int) 2.2f;", cStyleCastExpr()));
937 }
938
TEST(CStyleCast,DoesNotMatchOtherCasts)939 TEST(CStyleCast, DoesNotMatchOtherCasts) {
940 EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);"
941 "char q, *r = const_cast<char*>(&q);"
942 "void* s = reinterpret_cast<char*>(&s);"
943 "struct B { virtual ~B() {} }; struct D : B {};"
944 "B b;"
945 "D* t = dynamic_cast<D*>(&b);",
946 cStyleCastExpr()));
947 }
948
TEST(ImplicitCast,MatchesSimpleCase)949 TEST(ImplicitCast, MatchesSimpleCase) {
950 // This test creates an implicit const cast.
951 EXPECT_TRUE(matches("int x = 0; const int y = x;",
952 varDecl(hasInitializer(implicitCastExpr()))));
953 // This test creates an implicit cast from int to char.
954 EXPECT_TRUE(matches("char c = 0;",
955 varDecl(hasInitializer(implicitCastExpr()))));
956 // This test creates an implicit array-to-pointer cast.
957 EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
958 varDecl(hasInitializer(implicitCastExpr()))));
959 }
960
TEST(ImplicitCast,DoesNotMatchIncorrectly)961 TEST(ImplicitCast, DoesNotMatchIncorrectly) {
962 // This test verifies that implicitCastExpr() matches exactly when implicit casts
963 // are present, and that it ignores explicit and paren casts.
964
965 // These two test cases have no casts.
966 EXPECT_TRUE(notMatches("int x = 0;",
967 varDecl(hasInitializer(implicitCastExpr()))));
968 EXPECT_TRUE(notMatches("int x = 0, &y = x;",
969 varDecl(hasInitializer(implicitCastExpr()))));
970
971 EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;",
972 varDecl(hasInitializer(implicitCastExpr()))));
973 EXPECT_TRUE(notMatches("const int *p; int *q = const_cast<int *>(p);",
974 varDecl(hasInitializer(implicitCastExpr()))));
975
976 EXPECT_TRUE(notMatches("int x = (0);",
977 varDecl(hasInitializer(implicitCastExpr()))));
978 }
979
TEST(Statement,DoesNotMatchDeclarations)980 TEST(Statement, DoesNotMatchDeclarations) {
981 EXPECT_TRUE(notMatches("class X {};", stmt()));
982 }
983
TEST(Statement,MatchesCompoundStatments)984 TEST(Statement, MatchesCompoundStatments) {
985 EXPECT_TRUE(matches("void x() {}", stmt()));
986 }
987
TEST(DeclarationStatement,DoesNotMatchCompoundStatements)988 TEST(DeclarationStatement, DoesNotMatchCompoundStatements) {
989 EXPECT_TRUE(notMatches("void x() {}", declStmt()));
990 }
991
TEST(DeclarationStatement,MatchesVariableDeclarationStatements)992 TEST(DeclarationStatement, MatchesVariableDeclarationStatements) {
993 EXPECT_TRUE(matches("void x() { int a; }", declStmt()));
994 }
995
TEST(ExprWithCleanups,MatchesExprWithCleanups)996 TEST(ExprWithCleanups, MatchesExprWithCleanups) {
997 EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
998 "const Foo f = Foo();",
999 varDecl(hasInitializer(exprWithCleanups()))));
1000 EXPECT_FALSE(matches("struct Foo { }; Foo a;"
1001 "const Foo f = a;",
1002 varDecl(hasInitializer(exprWithCleanups()))));
1003 }
1004
TEST(InitListExpression,MatchesInitListExpression)1005 TEST(InitListExpression, MatchesInitListExpression) {
1006 EXPECT_TRUE(matches("int a[] = { 1, 2 };",
1007 initListExpr(hasType(asString("int [2]")))));
1008 EXPECT_TRUE(matches("struct B { int x, y; }; B b = { 5, 6 };",
1009 initListExpr(hasType(recordDecl(hasName("B"))))));
1010 EXPECT_TRUE(matches("struct S { S(void (*a)()); };"
1011 "void f();"
1012 "S s[1] = { &f };",
1013 declRefExpr(to(functionDecl(hasName("f"))))));
1014 EXPECT_TRUE(
1015 matches("int i[1] = {42, [0] = 43};", integerLiteral(equals(42))));
1016 }
1017
TEST(UsingDeclaration,MatchesUsingDeclarations)1018 TEST(UsingDeclaration, MatchesUsingDeclarations) {
1019 EXPECT_TRUE(matches("namespace X { int x; } using X::x;",
1020 usingDecl()));
1021 }
1022
TEST(UsingDeclaration,MatchesShadowUsingDelcarations)1023 TEST(UsingDeclaration, MatchesShadowUsingDelcarations) {
1024 EXPECT_TRUE(matches("namespace f { int a; } using f::a;",
1025 usingDecl(hasAnyUsingShadowDecl(hasName("a")))));
1026 }
1027
TEST(UsingDirectiveDeclaration,MatchesUsingNamespace)1028 TEST(UsingDirectiveDeclaration, MatchesUsingNamespace) {
1029 EXPECT_TRUE(matches("namespace X { int x; } using namespace X;",
1030 usingDirectiveDecl()));
1031 EXPECT_FALSE(
1032 matches("namespace X { int x; } using X::x;", usingDirectiveDecl()));
1033 }
1034
1035
TEST(While,MatchesWhileLoops)1036 TEST(While, MatchesWhileLoops) {
1037 EXPECT_TRUE(notMatches("void x() {}", whileStmt()));
1038 EXPECT_TRUE(matches("void x() { while(true); }", whileStmt()));
1039 EXPECT_TRUE(notMatches("void x() { do {} while(true); }", whileStmt()));
1040 }
1041
TEST(Do,MatchesDoLoops)1042 TEST(Do, MatchesDoLoops) {
1043 EXPECT_TRUE(matches("void x() { do {} while(true); }", doStmt()));
1044 EXPECT_TRUE(matches("void x() { do ; while(false); }", doStmt()));
1045 }
1046
TEST(Do,DoesNotMatchWhileLoops)1047 TEST(Do, DoesNotMatchWhileLoops) {
1048 EXPECT_TRUE(notMatches("void x() { while(true) {} }", doStmt()));
1049 }
1050
TEST(SwitchCase,MatchesCase)1051 TEST(SwitchCase, MatchesCase) {
1052 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchCase()));
1053 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchCase()));
1054 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchCase()));
1055 EXPECT_TRUE(notMatches("void x() { switch(42) {} }", switchCase()));
1056 }
1057
TEST(SwitchCase,MatchesSwitch)1058 TEST(SwitchCase, MatchesSwitch) {
1059 EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }", switchStmt()));
1060 EXPECT_TRUE(matches("void x() { switch(42) { default:; } }", switchStmt()));
1061 EXPECT_TRUE(matches("void x() { switch(42) default:; }", switchStmt()));
1062 EXPECT_TRUE(notMatches("void x() {}", switchStmt()));
1063 }
1064
TEST(ExceptionHandling,SimpleCases)1065 TEST(ExceptionHandling, SimpleCases) {
1066 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxCatchStmt()));
1067 EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", cxxTryStmt()));
1068 EXPECT_TRUE(
1069 notMatches("void foo() try { } catch(int X) { }", cxxThrowExpr()));
1070 EXPECT_TRUE(matches("void foo() try { throw; } catch(int X) { }",
1071 cxxThrowExpr()));
1072 EXPECT_TRUE(matches("void foo() try { throw 5;} catch(int X) { }",
1073 cxxThrowExpr()));
1074 EXPECT_TRUE(matches("void foo() try { throw; } catch(...) { }",
1075 cxxCatchStmt(isCatchAll())));
1076 EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }",
1077 cxxCatchStmt(isCatchAll())));
1078 EXPECT_TRUE(matches("void foo() try {} catch(int X) { }",
1079 varDecl(isExceptionVariable())));
1080 EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }",
1081 varDecl(isExceptionVariable())));
1082 }
1083
TEST(ParenExpression,SimpleCases)1084 TEST(ParenExpression, SimpleCases) {
1085 EXPECT_TRUE(matches("int i = (3);", parenExpr()));
1086 EXPECT_TRUE(matches("int i = (3 + 7);", parenExpr()));
1087 EXPECT_TRUE(notMatches("int i = 3;", parenExpr()));
1088 EXPECT_TRUE(notMatches("int foo() { return 1; }; int a = foo();",
1089 parenExpr()));
1090 }
1091
TEST(TypeMatching,MatchesTypes)1092 TEST(TypeMatching, MatchesTypes) {
1093 EXPECT_TRUE(matches("struct S {};", qualType().bind("loc")));
1094 }
1095
TEST(TypeMatching,MatchesConstantArrayTypes)1096 TEST(TypeMatching, MatchesConstantArrayTypes) {
1097 EXPECT_TRUE(matches("int a[2];", constantArrayType()));
1098 EXPECT_TRUE(notMatches(
1099 "void f() { int a[] = { 2, 3 }; int b[a[0]]; }",
1100 constantArrayType(hasElementType(builtinType()))));
1101
1102 EXPECT_TRUE(matches("int a[42];", constantArrayType(hasSize(42))));
1103 EXPECT_TRUE(matches("int b[2*21];", constantArrayType(hasSize(42))));
1104 EXPECT_TRUE(notMatches("int c[41], d[43];", constantArrayType(hasSize(42))));
1105 }
1106
TEST(TypeMatching,MatchesDependentSizedArrayTypes)1107 TEST(TypeMatching, MatchesDependentSizedArrayTypes) {
1108 EXPECT_TRUE(matches(
1109 "template <typename T, int Size> class array { T data[Size]; };",
1110 dependentSizedArrayType()));
1111 EXPECT_TRUE(notMatches(
1112 "int a[42]; int b[] = { 2, 3 }; void f() { int c[b[0]]; }",
1113 dependentSizedArrayType()));
1114 }
1115
TEST(TypeMatching,MatchesIncompleteArrayType)1116 TEST(TypeMatching, MatchesIncompleteArrayType) {
1117 EXPECT_TRUE(matches("int a[] = { 2, 3 };", incompleteArrayType()));
1118 EXPECT_TRUE(matches("void f(int a[]) {}", incompleteArrayType()));
1119
1120 EXPECT_TRUE(notMatches("int a[42]; void f() { int b[a[0]]; }",
1121 incompleteArrayType()));
1122 }
1123
TEST(TypeMatching,MatchesVariableArrayType)1124 TEST(TypeMatching, MatchesVariableArrayType) {
1125 EXPECT_TRUE(matches("void f(int b) { int a[b]; }", variableArrayType()));
1126 EXPECT_TRUE(notMatches("int a[] = {2, 3}; int b[42];", variableArrayType()));
1127
1128 EXPECT_TRUE(matches(
1129 "void f(int b) { int a[b]; }",
1130 variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
1131 varDecl(hasName("b")))))))));
1132 }
1133
1134
TEST(TypeMatching,MatchesAtomicTypes)1135 TEST(TypeMatching, MatchesAtomicTypes) {
1136 if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getOS() !=
1137 llvm::Triple::Win32) {
1138 // FIXME: Make this work for MSVC.
1139 EXPECT_TRUE(matches("_Atomic(int) i;", atomicType()));
1140
1141 EXPECT_TRUE(matches("_Atomic(int) i;",
1142 atomicType(hasValueType(isInteger()))));
1143 EXPECT_TRUE(notMatches("_Atomic(float) f;",
1144 atomicType(hasValueType(isInteger()))));
1145 }
1146 }
1147
TEST(TypeMatching,MatchesAutoTypes)1148 TEST(TypeMatching, MatchesAutoTypes) {
1149 EXPECT_TRUE(matches("auto i = 2;", autoType()));
1150 EXPECT_TRUE(matches("int v[] = { 2, 3 }; void f() { for (int i : v) {} }",
1151 autoType()));
1152
1153 // FIXME: Matching against the type-as-written can't work here, because the
1154 // type as written was not deduced.
1155 //EXPECT_TRUE(matches("auto a = 1;",
1156 // autoType(hasDeducedType(isInteger()))));
1157 //EXPECT_TRUE(notMatches("auto b = 2.0;",
1158 // autoType(hasDeducedType(isInteger()))));
1159 }
1160
TEST(TypeMatching,MatchesFunctionTypes)1161 TEST(TypeMatching, MatchesFunctionTypes) {
1162 EXPECT_TRUE(matches("int (*f)(int);", functionType()));
1163 EXPECT_TRUE(matches("void f(int i) {}", functionType()));
1164 }
1165
TEST(TypeMatching,IgnoringParens)1166 TEST(TypeMatching, IgnoringParens) {
1167 EXPECT_TRUE(
1168 notMatches("void (*fp)(void);", pointerType(pointee(functionType()))));
1169 EXPECT_TRUE(matches("void (*fp)(void);",
1170 pointerType(pointee(ignoringParens(functionType())))));
1171 }
1172
TEST(TypeMatching,MatchesFunctionProtoTypes)1173 TEST(TypeMatching, MatchesFunctionProtoTypes) {
1174 EXPECT_TRUE(matches("int (*f)(int);", functionProtoType()));
1175 EXPECT_TRUE(matches("void f(int i);", functionProtoType()));
1176 EXPECT_TRUE(matches("void f();", functionProtoType(parameterCountIs(0))));
1177 EXPECT_TRUE(notMatchesC("void f();", functionProtoType()));
1178 EXPECT_TRUE(
1179 matchesC("void f(void);", functionProtoType(parameterCountIs(0))));
1180 }
1181
TEST(TypeMatching,MatchesParenType)1182 TEST(TypeMatching, MatchesParenType) {
1183 EXPECT_TRUE(
1184 matches("int (*array)[4];", varDecl(hasType(pointsTo(parenType())))));
1185 EXPECT_TRUE(notMatches("int *array[4];", varDecl(hasType(parenType()))));
1186
1187 EXPECT_TRUE(matches(
1188 "int (*ptr_to_func)(int);",
1189 varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
1190 EXPECT_TRUE(notMatches(
1191 "int (*ptr_to_array)[4];",
1192 varDecl(hasType(pointsTo(parenType(innerType(functionType())))))));
1193 }
1194
TEST(TypeMatching,PointerTypes)1195 TEST(TypeMatching, PointerTypes) {
1196 // FIXME: Reactive when these tests can be more specific (not matching
1197 // implicit code on certain platforms), likely when we have hasDescendant for
1198 // Types/TypeLocs.
1199 //EXPECT_TRUE(matchAndVerifyResultTrue(
1200 // "int* a;",
1201 // pointerTypeLoc(pointeeLoc(typeLoc().bind("loc"))),
1202 // llvm::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
1203 //EXPECT_TRUE(matchAndVerifyResultTrue(
1204 // "int* a;",
1205 // pointerTypeLoc().bind("loc"),
1206 // llvm::make_unique<VerifyIdIsBoundTo<TypeLoc>>("loc", 1)));
1207 EXPECT_TRUE(matches(
1208 "int** a;",
1209 loc(pointerType(pointee(qualType())))));
1210 EXPECT_TRUE(matches(
1211 "int** a;",
1212 loc(pointerType(pointee(pointerType())))));
1213 EXPECT_TRUE(matches(
1214 "int* b; int* * const a = &b;",
1215 loc(qualType(isConstQualified(), pointerType()))));
1216
1217 std::string Fragment = "struct A { int i; }; int A::* ptr = &A::i;";
1218 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1219 hasType(blockPointerType()))));
1220 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
1221 hasType(memberPointerType()))));
1222 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1223 hasType(pointerType()))));
1224 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1225 hasType(referenceType()))));
1226 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1227 hasType(lValueReferenceType()))));
1228 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1229 hasType(rValueReferenceType()))));
1230
1231 Fragment = "int *ptr;";
1232 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1233 hasType(blockPointerType()))));
1234 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1235 hasType(memberPointerType()))));
1236 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ptr"),
1237 hasType(pointerType()))));
1238 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ptr"),
1239 hasType(referenceType()))));
1240
1241 Fragment = "int a; int &ref = a;";
1242 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1243 hasType(blockPointerType()))));
1244 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1245 hasType(memberPointerType()))));
1246 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1247 hasType(pointerType()))));
1248 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1249 hasType(referenceType()))));
1250 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1251 hasType(lValueReferenceType()))));
1252 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1253 hasType(rValueReferenceType()))));
1254
1255 Fragment = "int &&ref = 2;";
1256 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1257 hasType(blockPointerType()))));
1258 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1259 hasType(memberPointerType()))));
1260 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1261 hasType(pointerType()))));
1262 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1263 hasType(referenceType()))));
1264 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("ref"),
1265 hasType(lValueReferenceType()))));
1266 EXPECT_TRUE(matches(Fragment, varDecl(hasName("ref"),
1267 hasType(rValueReferenceType()))));
1268 }
1269
TEST(TypeMatching,AutoRefTypes)1270 TEST(TypeMatching, AutoRefTypes) {
1271 std::string Fragment = "auto a = 1;"
1272 "auto b = a;"
1273 "auto &c = a;"
1274 "auto &&d = c;"
1275 "auto &&e = 2;";
1276 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("a"),
1277 hasType(referenceType()))));
1278 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("b"),
1279 hasType(referenceType()))));
1280 EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
1281 hasType(referenceType()))));
1282 EXPECT_TRUE(matches(Fragment, varDecl(hasName("c"),
1283 hasType(lValueReferenceType()))));
1284 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("c"),
1285 hasType(rValueReferenceType()))));
1286 EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
1287 hasType(referenceType()))));
1288 EXPECT_TRUE(matches(Fragment, varDecl(hasName("d"),
1289 hasType(lValueReferenceType()))));
1290 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("d"),
1291 hasType(rValueReferenceType()))));
1292 EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
1293 hasType(referenceType()))));
1294 EXPECT_TRUE(notMatches(Fragment, varDecl(hasName("e"),
1295 hasType(lValueReferenceType()))));
1296 EXPECT_TRUE(matches(Fragment, varDecl(hasName("e"),
1297 hasType(rValueReferenceType()))));
1298 }
1299
TEST(TypeMatching,MatchesEnumTypes)1300 TEST(TypeMatching, MatchesEnumTypes) {
1301 EXPECT_TRUE(matches("enum Color { Green }; Color color;",
1302 loc(enumType())));
1303 EXPECT_TRUE(matches("enum class Color { Green }; Color color;",
1304 loc(enumType())));
1305 }
1306
TEST(TypeMatching,MatchesPointersToConstTypes)1307 TEST(TypeMatching, MatchesPointersToConstTypes) {
1308 EXPECT_TRUE(matches("int b; int * const a = &b;",
1309 loc(pointerType())));
1310 EXPECT_TRUE(matches("int b; int * const a = &b;",
1311 loc(pointerType())));
1312 EXPECT_TRUE(matches(
1313 "int b; const int * a = &b;",
1314 loc(pointerType(pointee(builtinType())))));
1315 EXPECT_TRUE(matches(
1316 "int b; const int * a = &b;",
1317 pointerType(pointee(builtinType()))));
1318 }
1319
TEST(TypeMatching,MatchesTypedefTypes)1320 TEST(TypeMatching, MatchesTypedefTypes) {
1321 EXPECT_TRUE(matches("typedef int X; X a;", varDecl(hasName("a"),
1322 hasType(typedefType()))));
1323 }
1324
TEST(TypeMatching,MatchesTemplateSpecializationType)1325 TEST(TypeMatching, MatchesTemplateSpecializationType) {
1326 EXPECT_TRUE(matches("template <typename T> class A{}; A<int> a;",
1327 templateSpecializationType()));
1328 }
1329
TEST(TypeMatching,MatchesRecordType)1330 TEST(TypeMatching, MatchesRecordType) {
1331 EXPECT_TRUE(matches("class C{}; C c;", recordType()));
1332 EXPECT_TRUE(matches("struct S{}; S s;",
1333 recordType(hasDeclaration(recordDecl(hasName("S"))))));
1334 EXPECT_TRUE(notMatches("int i;",
1335 recordType(hasDeclaration(recordDecl(hasName("S"))))));
1336 }
1337
TEST(TypeMatching,MatchesElaboratedType)1338 TEST(TypeMatching, MatchesElaboratedType) {
1339 EXPECT_TRUE(matches(
1340 "namespace N {"
1341 " namespace M {"
1342 " class D {};"
1343 " }"
1344 "}"
1345 "N::M::D d;", elaboratedType()));
1346 EXPECT_TRUE(matches("class C {} c;", elaboratedType()));
1347 EXPECT_TRUE(notMatches("class C {}; C c;", elaboratedType()));
1348 }
1349
TEST(TypeMatching,MatchesSubstTemplateTypeParmType)1350 TEST(TypeMatching, MatchesSubstTemplateTypeParmType) {
1351 const std::string code = "template <typename T>"
1352 "int F() {"
1353 " return 1 + T();"
1354 "}"
1355 "int i = F<int>();";
1356 EXPECT_FALSE(matches(code, binaryOperator(hasLHS(
1357 expr(hasType(substTemplateTypeParmType()))))));
1358 EXPECT_TRUE(matches(code, binaryOperator(hasRHS(
1359 expr(hasType(substTemplateTypeParmType()))))));
1360 }
1361
TEST(NNS,MatchesNestedNameSpecifiers)1362 TEST(NNS, MatchesNestedNameSpecifiers) {
1363 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;",
1364 nestedNameSpecifier()));
1365 EXPECT_TRUE(matches("template <typename T> class A { typename T::B b; };",
1366 nestedNameSpecifier()));
1367 EXPECT_TRUE(matches("struct A { void f(); }; void A::f() {}",
1368 nestedNameSpecifier()));
1369 EXPECT_TRUE(matches("namespace a { namespace b {} } namespace ab = a::b;",
1370 nestedNameSpecifier()));
1371
1372 EXPECT_TRUE(matches(
1373 "struct A { static void f() {} }; void g() { A::f(); }",
1374 nestedNameSpecifier()));
1375 EXPECT_TRUE(notMatches(
1376 "struct A { static void f() {} }; void g(A* a) { a->f(); }",
1377 nestedNameSpecifier()));
1378 }
1379
TEST(NullStatement,SimpleCases)1380 TEST(NullStatement, SimpleCases) {
1381 EXPECT_TRUE(matches("void f() {int i;;}", nullStmt()));
1382 EXPECT_TRUE(notMatches("void f() {int i;}", nullStmt()));
1383 }
1384
TEST(NS,Alias)1385 TEST(NS, Alias) {
1386 EXPECT_TRUE(matches("namespace test {} namespace alias = ::test;",
1387 namespaceAliasDecl(hasName("alias"))));
1388 }
1389
TEST(NNS,MatchesTypes)1390 TEST(NNS, MatchesTypes) {
1391 NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
1392 specifiesType(hasDeclaration(recordDecl(hasName("A")))));
1393 EXPECT_TRUE(matches("struct A { struct B {}; }; A::B b;", Matcher));
1394 EXPECT_TRUE(matches("struct A { struct B { struct C {}; }; }; A::B::C c;",
1395 Matcher));
1396 EXPECT_TRUE(notMatches("namespace A { struct B {}; } A::B b;", Matcher));
1397 }
1398
TEST(NNS,MatchesNamespaceDecls)1399 TEST(NNS, MatchesNamespaceDecls) {
1400 NestedNameSpecifierMatcher Matcher = nestedNameSpecifier(
1401 specifiesNamespace(hasName("ns")));
1402 EXPECT_TRUE(matches("namespace ns { struct A {}; } ns::A a;", Matcher));
1403 EXPECT_TRUE(notMatches("namespace xx { struct A {}; } xx::A a;", Matcher));
1404 EXPECT_TRUE(notMatches("struct ns { struct A {}; }; ns::A a;", Matcher));
1405 }
1406
TEST(NNS,MatchesNestedNameSpecifierPrefixes)1407 TEST(NNS, MatchesNestedNameSpecifierPrefixes) {
1408 EXPECT_TRUE(matches(
1409 "struct A { struct B { struct C {}; }; }; A::B::C c;",
1410 nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A"))))));
1411 EXPECT_TRUE(matches(
1412 "struct A { struct B { struct C {}; }; }; A::B::C c;",
1413 nestedNameSpecifierLoc(hasPrefix(
1414 specifiesTypeLoc(loc(qualType(asString("struct A"))))))));
1415 }
1416
1417
1418 template <typename T>
1419 class VerifyAncestorHasChildIsEqual : public BoundNodesCallback {
1420 public:
run(const BoundNodes * Nodes)1421 bool run(const BoundNodes *Nodes) override { return false; }
1422
run(const BoundNodes * Nodes,ASTContext * Context)1423 bool run(const BoundNodes *Nodes, ASTContext *Context) override {
1424 const T *Node = Nodes->getNodeAs<T>("");
1425 return verify(*Nodes, *Context, Node);
1426 }
1427
verify(const BoundNodes & Nodes,ASTContext & Context,const Stmt * Node)1428 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Stmt *Node) {
1429 // Use the original typed pointer to verify we can pass pointers to subtypes
1430 // to equalsNode.
1431 const T *TypedNode = cast<T>(Node);
1432 return selectFirst<T>(
1433 "", match(stmt(hasParent(
1434 stmt(has(stmt(equalsNode(TypedNode)))).bind(""))),
1435 *Node, Context)) != nullptr;
1436 }
verify(const BoundNodes & Nodes,ASTContext & Context,const Decl * Node)1437 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Decl *Node) {
1438 // Use the original typed pointer to verify we can pass pointers to subtypes
1439 // to equalsNode.
1440 const T *TypedNode = cast<T>(Node);
1441 return selectFirst<T>(
1442 "", match(decl(hasParent(
1443 decl(has(decl(equalsNode(TypedNode)))).bind(""))),
1444 *Node, Context)) != nullptr;
1445 }
verify(const BoundNodes & Nodes,ASTContext & Context,const Type * Node)1446 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Type *Node) {
1447 // Use the original typed pointer to verify we can pass pointers to subtypes
1448 // to equalsNode.
1449 const T *TypedNode = cast<T>(Node);
1450 const auto *Dec = Nodes.getNodeAs<FieldDecl>("decl");
1451 return selectFirst<T>(
1452 "", match(fieldDecl(hasParent(decl(has(fieldDecl(
1453 hasType(type(equalsNode(TypedNode)).bind(""))))))),
1454 *Dec, Context)) != nullptr;
1455 }
1456 };
1457
TEST(IsEqualTo,MatchesNodesByIdentity)1458 TEST(IsEqualTo, MatchesNodesByIdentity) {
1459 EXPECT_TRUE(matchAndVerifyResultTrue(
1460 "class X { class Y {}; };", recordDecl(hasName("::X::Y")).bind(""),
1461 llvm::make_unique<VerifyAncestorHasChildIsEqual<CXXRecordDecl>>()));
1462 EXPECT_TRUE(matchAndVerifyResultTrue(
1463 "void f() { if (true) if(true) {} }", ifStmt().bind(""),
1464 llvm::make_unique<VerifyAncestorHasChildIsEqual<IfStmt>>()));
1465 EXPECT_TRUE(matchAndVerifyResultTrue(
1466 "class X { class Y {} y; };",
1467 fieldDecl(hasName("y"), hasType(type().bind(""))).bind("decl"),
1468 llvm::make_unique<VerifyAncestorHasChildIsEqual<Type>>()));
1469 }
1470
TEST(TypedefDeclMatcher,Match)1471 TEST(TypedefDeclMatcher, Match) {
1472 EXPECT_TRUE(matches("typedef int typedefDeclTest;",
1473 typedefDecl(hasName("typedefDeclTest"))));
1474 EXPECT_TRUE(notMatches("using typedefDeclTest2 = int;",
1475 typedefDecl(hasName("typedefDeclTest2"))));
1476 }
1477
TEST(TypeAliasDeclMatcher,Match)1478 TEST(TypeAliasDeclMatcher, Match) {
1479 EXPECT_TRUE(matches("using typeAliasTest2 = int;",
1480 typeAliasDecl(hasName("typeAliasTest2"))));
1481 EXPECT_TRUE(notMatches("typedef int typeAliasTest;",
1482 typeAliasDecl(hasName("typeAliasTest"))));
1483 }
1484
TEST(TypedefNameDeclMatcher,Match)1485 TEST(TypedefNameDeclMatcher, Match) {
1486 EXPECT_TRUE(matches("typedef int typedefNameDeclTest1;",
1487 typedefNameDecl(hasName("typedefNameDeclTest1"))));
1488 EXPECT_TRUE(matches("using typedefNameDeclTest2 = int;",
1489 typedefNameDecl(hasName("typedefNameDeclTest2"))));
1490 }
1491
TEST(ObjCMessageExprMatcher,SimpleExprs)1492 TEST(ObjCMessageExprMatcher, SimpleExprs) {
1493 // don't find ObjCMessageExpr where none are present
1494 EXPECT_TRUE(notMatchesObjC("", objcMessageExpr(anything())));
1495
1496 std::string Objc1String =
1497 "@interface Str "
1498 " - (Str *)uppercaseString:(Str *)str;"
1499 "@end "
1500 "@interface foo "
1501 "- (void)meth:(Str *)text;"
1502 "@end "
1503 " "
1504 "@implementation foo "
1505 "- (void) meth:(Str *)text { "
1506 " [self contents];"
1507 " Str *up = [text uppercaseString];"
1508 "} "
1509 "@end ";
1510 EXPECT_TRUE(matchesObjC(
1511 Objc1String,
1512 objcMessageExpr(anything())));
1513 EXPECT_TRUE(matchesObjC(
1514 Objc1String,
1515 objcMessageExpr(hasSelector("contents"))));
1516 EXPECT_TRUE(matchesObjC(
1517 Objc1String,
1518 objcMessageExpr(matchesSelector("cont*"))));
1519 EXPECT_FALSE(matchesObjC(
1520 Objc1String,
1521 objcMessageExpr(matchesSelector("?cont*"))));
1522 EXPECT_TRUE(notMatchesObjC(
1523 Objc1String,
1524 objcMessageExpr(hasSelector("contents"), hasNullSelector())));
1525 EXPECT_TRUE(matchesObjC(
1526 Objc1String,
1527 objcMessageExpr(hasSelector("contents"), hasUnarySelector())));
1528 EXPECT_TRUE(matchesObjC(
1529 Objc1String,
1530 objcMessageExpr(hasSelector("contents"), numSelectorArgs(0))));
1531 EXPECT_TRUE(matchesObjC(
1532 Objc1String,
1533 objcMessageExpr(matchesSelector("uppercase*"),
1534 argumentCountIs(0)
1535 )));
1536 }
1537
1538 } // namespace ast_matchers
1539 } // namespace clang
1540