1 //===- unittest/AST/SourceLocationTest.cpp - AST source loc 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 // This file contains tests for SourceLocation and SourceRange fields 11 // in AST nodes. 12 // 13 // FIXME: In the long-term, when we test more than source locations, we may 14 // want to have a unit test file for an AST node (or group of related nodes), 15 // rather than a unit test file for source locations for all AST nodes. 16 // 17 //===----------------------------------------------------------------------===// 18 19 #include "clang/AST/ASTContext.h" 20 #include "MatchVerifier.h" 21 #include "clang/ASTMatchers/ASTMatchFinder.h" 22 #include "clang/ASTMatchers/ASTMatchers.h" 23 #include "clang/Tooling/Tooling.h" 24 #include "gtest/gtest.h" 25 26 namespace clang { 27 namespace ast_matchers { 28 29 // FIXME: Pull the *Verifier tests into their own test file. 30 31 TEST(MatchVerifier, ParseError) { 32 LocationVerifier<VarDecl> Verifier; 33 Verifier.expectLocation(1, 1); 34 EXPECT_FALSE(Verifier.match("int i", varDecl())); 35 } 36 37 TEST(MatchVerifier, NoMatch) { 38 LocationVerifier<VarDecl> Verifier; 39 Verifier.expectLocation(1, 1); 40 EXPECT_FALSE(Verifier.match("int i;", recordDecl())); 41 } 42 43 TEST(MatchVerifier, WrongType) { 44 LocationVerifier<RecordDecl> Verifier; 45 Verifier.expectLocation(1, 1); 46 EXPECT_FALSE(Verifier.match("int i;", varDecl())); 47 } 48 49 TEST(LocationVerifier, WrongLocation) { 50 LocationVerifier<VarDecl> Verifier; 51 Verifier.expectLocation(1, 1); 52 EXPECT_FALSE(Verifier.match("int i;", varDecl())); 53 } 54 55 TEST(RangeVerifier, WrongRange) { 56 RangeVerifier<VarDecl> Verifier; 57 Verifier.expectRange(1, 1, 1, 1); 58 EXPECT_FALSE(Verifier.match("int i;", varDecl())); 59 } 60 61 class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> { 62 protected: 63 virtual SourceRange getRange(const LabelStmt &Node) { 64 return Node.getDecl()->getSourceRange(); 65 } 66 }; 67 68 TEST(LabelDecl, Range) { 69 LabelDeclRangeVerifier Verifier; 70 Verifier.expectRange(1, 12, 1, 12); 71 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt())); 72 } 73 74 TEST(LabelStmt, Range) { 75 RangeVerifier<LabelStmt> Verifier; 76 Verifier.expectRange(1, 12, 1, 15); 77 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt())); 78 } 79 80 TEST(ParmVarDecl, KNRLocation) { 81 LocationVerifier<ParmVarDecl> Verifier; 82 Verifier.expectLocation(1, 8); 83 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C)); 84 } 85 86 TEST(ParmVarDecl, KNRRange) { 87 RangeVerifier<ParmVarDecl> Verifier; 88 Verifier.expectRange(1, 8, 1, 8); 89 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C)); 90 } 91 92 TEST(CXXNewExpr, ArrayRange) { 93 RangeVerifier<CXXNewExpr> Verifier; 94 Verifier.expectRange(1, 12, 1, 22); 95 EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", newExpr())); 96 } 97 98 TEST(CXXNewExpr, ParenRange) { 99 RangeVerifier<CXXNewExpr> Verifier; 100 Verifier.expectRange(1, 12, 1, 20); 101 EXPECT_TRUE(Verifier.match("void f() { new int(); }", newExpr())); 102 } 103 104 TEST(MemberExpr, ImplicitMemberRange) { 105 RangeVerifier<MemberExpr> Verifier; 106 Verifier.expectRange(2, 30, 2, 30); 107 EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n" 108 "int foo(const S& s) { return s; }", 109 memberExpr())); 110 } 111 112 TEST(VarDecl, VMTypeFixedVarDeclRange) { 113 RangeVerifier<VarDecl> Verifier; 114 Verifier.expectRange(1, 1, 1, 23); 115 EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];", 116 varDecl(), Lang_C89)); 117 } 118 119 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) { 120 RangeVerifier<CXXConstructorDecl> Verifier; 121 Verifier.expectRange(1, 11, 1, 13); 122 EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl())); 123 } 124 125 TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) { 126 RangeVerifier<CompoundLiteralExpr> Verifier; 127 Verifier.expectRange(2, 11, 2, 22); 128 EXPECT_TRUE(Verifier.match( 129 "typedef int int2 __attribute__((ext_vector_type(2)));\n" 130 "int2 i2 = (int2){1, 2};", compoundLiteralExpr())); 131 } 132 133 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) { 134 RangeVerifier<CompoundLiteralExpr> Verifier; 135 Verifier.expectRange(2, 20, 2, 31); 136 EXPECT_TRUE(Verifier.match( 137 "typedef int int2 __attribute__((ext_vector_type(2)));\n" 138 "constant int2 i2 = (int2)(1, 2);", 139 compoundLiteralExpr(), Lang_OpenCL)); 140 } 141 142 TEST(InitListExpr, VectorLiteralListBraceRange) { 143 RangeVerifier<InitListExpr> Verifier; 144 Verifier.expectRange(2, 17, 2, 22); 145 EXPECT_TRUE(Verifier.match( 146 "typedef int int2 __attribute__((ext_vector_type(2)));\n" 147 "int2 i2 = (int2){1, 2};", initListExpr())); 148 } 149 150 TEST(InitListExpr, VectorLiteralInitListParens) { 151 RangeVerifier<InitListExpr> Verifier; 152 Verifier.expectRange(2, 26, 2, 31); 153 EXPECT_TRUE(Verifier.match( 154 "typedef int int2 __attribute__((ext_vector_type(2)));\n" 155 "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL)); 156 } 157 158 class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> { 159 protected: 160 virtual SourceRange getRange(const TypeLoc &Node) { 161 TemplateSpecializationTypeLoc T = 162 Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>(); 163 assert(!T.isNull()); 164 return SourceRange(T.getLAngleLoc(), T.getRAngleLoc()); 165 } 166 }; 167 168 TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) { 169 TemplateAngleBracketLocRangeVerifier Verifier; 170 Verifier.expectRange(2, 8, 2, 10); 171 EXPECT_TRUE(Verifier.match( 172 "template<typename T> struct A {}; struct B{}; void f(\n" 173 "const A<B>&);", 174 loc(templateSpecializationType()))); 175 } 176 177 TEST(CXXNewExpr, TypeParenRange) { 178 RangeVerifier<CXXNewExpr> Verifier; 179 Verifier.expectRange(1, 10, 1, 18); 180 EXPECT_TRUE(Verifier.match("int* a = new (int);", newExpr())); 181 } 182 183 class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> { 184 protected: 185 virtual SourceRange getRange(const TypeLoc &Node) { 186 UnaryTransformTypeLoc T = 187 Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>(); 188 assert(!T.isNull()); 189 return SourceRange(T.getLParenLoc(), T.getRParenLoc()); 190 } 191 }; 192 193 TEST(UnaryTransformTypeLoc, ParensRange) { 194 UnaryTransformTypeLocParensRangeVerifier Verifier; 195 Verifier.expectRange(3, 26, 3, 28); 196 EXPECT_TRUE(Verifier.match( 197 "template <typename T>\n" 198 "struct S {\n" 199 "typedef __underlying_type(T) type;\n" 200 "};", 201 loc(unaryTransformType()))); 202 } 203 204 TEST(CXXFunctionalCastExpr, SourceRange) { 205 RangeVerifier<CXXFunctionalCastExpr> Verifier; 206 Verifier.expectRange(2, 10, 2, 14); 207 EXPECT_TRUE(Verifier.match( 208 "int foo() {\n" 209 " return int{};\n" 210 "}", 211 functionalCastExpr(), Lang_CXX11)); 212 } 213 214 TEST(CXXConstructExpr, SourceRange) { 215 RangeVerifier<CXXConstructExpr> Verifier; 216 Verifier.expectRange(3, 14, 3, 19); 217 EXPECT_TRUE(Verifier.match( 218 "struct A { A(int, int); };\n" 219 "void f(A a);\n" 220 "void g() { f({0, 0}); }", 221 constructExpr(), Lang_CXX11)); 222 } 223 224 TEST(CXXTemporaryObjectExpr, SourceRange) { 225 RangeVerifier<CXXTemporaryObjectExpr> Verifier; 226 Verifier.expectRange(2, 6, 2, 12); 227 EXPECT_TRUE(Verifier.match( 228 "struct A { A(int, int); };\n" 229 "A a( A{0, 0} );", 230 temporaryObjectExpr(), Lang_CXX11)); 231 } 232 233 TEST(CXXUnresolvedConstructExpr, SourceRange) { 234 RangeVerifier<CXXUnresolvedConstructExpr> Verifier; 235 Verifier.expectRange(3, 10, 3, 12); 236 std::vector<std::string> Args; 237 Args.push_back("-fno-delayed-template-parsing"); 238 EXPECT_TRUE(Verifier.match( 239 "template <typename U>\n" 240 "U foo() {\n" 241 " return U{};\n" 242 "}", 243 unresolvedConstructExpr(), Args, Lang_CXX11)); 244 } 245 246 TEST(UsingDecl, SourceRange) { 247 RangeVerifier<UsingDecl> Verifier; 248 Verifier.expectRange(2, 22, 2, 25); 249 EXPECT_TRUE(Verifier.match( 250 "class B { protected: int i; };\n" 251 "class D : public B { B::i; };", 252 usingDecl())); 253 } 254 255 TEST(UnresolvedUsingValueDecl, SourceRange) { 256 RangeVerifier<UnresolvedUsingValueDecl> Verifier; 257 Verifier.expectRange(3, 3, 3, 6); 258 EXPECT_TRUE(Verifier.match( 259 "template <typename B>\n" 260 "class D : public B {\n" 261 " B::i;\n" 262 "};", 263 unresolvedUsingValueDecl())); 264 } 265 266 TEST(FriendDecl, FriendNonMemberFunctionLocation) { 267 LocationVerifier<FriendDecl> Verifier; 268 Verifier.expectLocation(2, 13); 269 EXPECT_TRUE(Verifier.match("struct A {\n" 270 "friend void f();\n" 271 "};\n", 272 friendDecl())); 273 } 274 275 TEST(FriendDecl, FriendNonMemberFunctionRange) { 276 RangeVerifier<FriendDecl> Verifier; 277 Verifier.expectRange(2, 1, 2, 15); 278 EXPECT_TRUE(Verifier.match("struct A {\n" 279 "friend void f();\n" 280 "};\n", 281 friendDecl())); 282 } 283 284 TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) { 285 LocationVerifier<FriendDecl> Verifier; 286 Verifier.expectLocation(2, 12); 287 EXPECT_TRUE(Verifier.match("struct A {\n" 288 "friend int f() { return 0; }\n" 289 "};\n", 290 friendDecl())); 291 } 292 293 TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) { 294 RangeVerifier<FriendDecl> Verifier; 295 Verifier.expectRange(2, 1, 2, 28); 296 EXPECT_TRUE(Verifier.match("struct A {\n" 297 "friend int f() { return 0; }\n" 298 "};\n", 299 friendDecl())); 300 } 301 302 TEST(FriendDecl, FriendElaboratedTypeLocation) { 303 LocationVerifier<FriendDecl> Verifier; 304 Verifier.expectLocation(2, 8); 305 EXPECT_TRUE(Verifier.match("struct A {\n" 306 "friend class B;\n" 307 "};\n", 308 friendDecl())); 309 } 310 311 TEST(FriendDecl, FriendElaboratedTypeRange) { 312 RangeVerifier<FriendDecl> Verifier; 313 Verifier.expectRange(2, 1, 2, 14); 314 EXPECT_TRUE(Verifier.match("struct A {\n" 315 "friend class B;\n" 316 "};\n", 317 friendDecl())); 318 } 319 320 TEST(FriendDecl, FriendSimpleTypeLocation) { 321 LocationVerifier<FriendDecl> Verifier; 322 Verifier.expectLocation(3, 8); 323 EXPECT_TRUE(Verifier.match("class B;\n" 324 "struct A {\n" 325 "friend B;\n" 326 "};\n", 327 friendDecl(), Lang_CXX11)); 328 } 329 330 TEST(FriendDecl, FriendSimpleTypeRange) { 331 RangeVerifier<FriendDecl> Verifier; 332 Verifier.expectRange(3, 1, 3, 8); 333 EXPECT_TRUE(Verifier.match("class B;\n" 334 "struct A {\n" 335 "friend B;\n" 336 "};\n", 337 friendDecl(), Lang_CXX11)); 338 } 339 340 TEST(FriendDecl, FriendTemplateParameterLocation) { 341 LocationVerifier<FriendDecl> Verifier; 342 Verifier.expectLocation(3, 8); 343 EXPECT_TRUE(Verifier.match("template <typename T>\n" 344 "struct A {\n" 345 "friend T;\n" 346 "};\n", 347 friendDecl(), Lang_CXX11)); 348 } 349 350 TEST(FriendDecl, FriendTemplateParameterRange) { 351 RangeVerifier<FriendDecl> Verifier; 352 Verifier.expectRange(3, 1, 3, 8); 353 EXPECT_TRUE(Verifier.match("template <typename T>\n" 354 "struct A {\n" 355 "friend T;\n" 356 "};\n", 357 friendDecl(), Lang_CXX11)); 358 } 359 360 TEST(FriendDecl, FriendDecltypeLocation) { 361 LocationVerifier<FriendDecl> Verifier; 362 Verifier.expectLocation(4, 8); 363 EXPECT_TRUE(Verifier.match("struct A;\n" 364 "A foo();\n" 365 "struct A {\n" 366 "friend decltype(foo());\n" 367 "};\n", 368 friendDecl(), Lang_CXX11)); 369 } 370 371 TEST(FriendDecl, FriendDecltypeRange) { 372 RangeVerifier<FriendDecl> Verifier; 373 Verifier.expectRange(4, 1, 4, 8); 374 EXPECT_TRUE(Verifier.match("struct A;\n" 375 "A foo();\n" 376 "struct A {\n" 377 "friend decltype(foo());\n" 378 "};\n", 379 friendDecl(), Lang_CXX11)); 380 } 381 382 TEST(FriendDecl, FriendConstructorDestructorLocation) { 383 const std::string Code = "struct B {\n" 384 "B();\n" 385 "~B();\n" 386 "};\n" 387 "struct A {\n" 388 "friend B::B(), B::~B();\n" 389 "};\n"; 390 LocationVerifier<FriendDecl> ConstructorVerifier; 391 ConstructorVerifier.expectLocation(6, 11); 392 EXPECT_TRUE(ConstructorVerifier.match( 393 Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); 394 LocationVerifier<FriendDecl> DestructorVerifier; 395 DestructorVerifier.expectLocation(6, 19); 396 EXPECT_TRUE(DestructorVerifier.match( 397 Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); 398 } 399 400 TEST(FriendDecl, FriendConstructorDestructorRange) { 401 const std::string Code = "struct B {\n" 402 "B();\n" 403 "~B();\n" 404 "};\n" 405 "struct A {\n" 406 "friend B::B(), B::~B();\n" 407 "};\n"; 408 RangeVerifier<FriendDecl> ConstructorVerifier; 409 ConstructorVerifier.expectRange(6, 1, 6, 13); 410 EXPECT_TRUE(ConstructorVerifier.match( 411 Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); 412 RangeVerifier<FriendDecl> DestructorVerifier; 413 DestructorVerifier.expectRange(6, 1, 6, 22); 414 EXPECT_TRUE(DestructorVerifier.match( 415 Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); 416 } 417 418 TEST(FriendDecl, FriendTemplateFunctionLocation) { 419 LocationVerifier<FriendDecl> Verifier; 420 Verifier.expectLocation(3, 13); 421 EXPECT_TRUE(Verifier.match("struct A {\n" 422 "template <typename T>\n" 423 "friend void f();\n" 424 "};\n", 425 friendDecl())); 426 } 427 428 TEST(FriendDecl, FriendTemplateFunctionRange) { 429 RangeVerifier<FriendDecl> Verifier; 430 Verifier.expectRange(2, 1, 3, 15); 431 EXPECT_TRUE(Verifier.match("struct A {\n" 432 "template <typename T>\n" 433 "friend void f();\n" 434 "};\n", 435 friendDecl())); 436 } 437 438 TEST(FriendDecl, FriendTemplateClassLocation) { 439 LocationVerifier<FriendDecl> Verifier; 440 Verifier.expectLocation(3, 14); 441 EXPECT_TRUE(Verifier.match("struct A {\n" 442 "template <typename T>\n" 443 "friend class B;\n" 444 "};\n", 445 friendDecl())); 446 } 447 448 TEST(FriendDecl, FriendTemplateClassRange) { 449 RangeVerifier<FriendDecl> Verifier; 450 Verifier.expectRange(2, 1, 3, 14); 451 EXPECT_TRUE(Verifier.match("struct A {\n" 452 "template <typename T>\n" 453 "friend class B;\n" 454 "};\n", 455 friendDecl())); 456 } 457 458 TEST(FriendDecl, FriendInlineFunctionLocation) { 459 LocationVerifier<FriendDecl> Verifier; 460 Verifier.expectLocation(2, 19); 461 EXPECT_TRUE(Verifier.match("struct A {\n" 462 "int inline friend f() { return 0; }" 463 "};\n", 464 friendDecl())); 465 } 466 467 TEST(FriendDecl, FriendInlineFunctionRange) { 468 RangeVerifier<FriendDecl> Verifier; 469 Verifier.expectRange(2, 1, 2, 35); 470 EXPECT_TRUE(Verifier.match("struct A {\n" 471 "int inline friend f() { return 0; }" 472 "};\n", 473 friendDecl(), Lang_CXX11)); 474 } 475 476 TEST(FriendDecl, InstantiationSourceRange) { 477 RangeVerifier<FriendDecl> Verifier; 478 Verifier.expectRange(4, 3, 4, 35); 479 EXPECT_TRUE(Verifier.match( 480 "template <typename T> class S;\n" 481 "template<class T> void operator+(S<T> x);\n" 482 "template<class T> struct S {\n" 483 " friend void operator+<>(S<T> src);\n" 484 "};\n" 485 "void test(S<double> s) { +s; }", 486 friendDecl(hasParent(recordDecl(isTemplateInstantiation()))))); 487 } 488 489 TEST(ObjCMessageExpr, CXXConstructExprRange) { 490 RangeVerifier<CXXConstructExpr> Verifier; 491 Verifier.expectRange(5, 25, 5, 27); 492 EXPECT_TRUE(Verifier.match( 493 "struct A { int a; };\n" 494 "@interface B {}\n" 495 "+ (void) f1: (A)arg;\n" 496 "@end\n" 497 "void f2() { A a; [B f1: (a)]; }\n", 498 constructExpr(), Lang_OBJCXX)); 499 } 500 501 } // end namespace ast_matchers 502 } // end namespace clang 503