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