1 //===-- FindTargetTests.cpp --------------------------*- C++ -*------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 #include "FindTarget.h" 9 10 #include "Selection.h" 11 #include "TestTU.h" 12 #include "clang/AST/Decl.h" 13 #include "clang/AST/DeclTemplate.h" 14 #include "clang/Basic/SourceLocation.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/Support/Casting.h" 17 #include "llvm/Support/raw_ostream.h" 18 #include "llvm/Testing/Annotations/Annotations.h" 19 #include "gmock/gmock.h" 20 #include "gtest/gtest.h" 21 #include <initializer_list> 22 23 namespace clang { 24 namespace clangd { 25 namespace { 26 27 // A referenced Decl together with its DeclRelationSet, for assertions. 28 // 29 // There's no great way to assert on the "content" of a Decl in the general case 30 // that's both expressive and unambiguous (e.g. clearly distinguishes between 31 // templated decls and their specializations). 32 // 33 // We use the result of pretty-printing the decl, with the {body} truncated. 34 struct PrintedDecl { 35 PrintedDecl(const char *Name, DeclRelationSet Relations = {}) 36 : Name(Name), Relations(Relations) {} 37 PrintedDecl(const NamedDecl *D, DeclRelationSet Relations = {}) 38 : Relations(Relations) { 39 std::string S; 40 llvm::raw_string_ostream OS(S); 41 D->print(OS); 42 llvm::StringRef FirstLine = 43 llvm::StringRef(OS.str()).take_until([](char C) { return C == '\n'; }); 44 FirstLine = FirstLine.rtrim(" {"); 45 Name = std::string(FirstLine.rtrim(" {")); 46 } 47 48 std::string Name; 49 DeclRelationSet Relations; 50 }; 51 bool operator==(const PrintedDecl &L, const PrintedDecl &R) { 52 return std::tie(L.Name, L.Relations) == std::tie(R.Name, R.Relations); 53 } 54 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const PrintedDecl &D) { 55 return OS << D.Name << " Rel=" << D.Relations; 56 } 57 58 // The test cases in for targetDecl() take the form 59 // - a piece of code (Code = "...") 60 // - Code should have a single AST node marked as a [[range]] 61 // - an EXPECT_DECLS() assertion that verify the type of node selected, and 62 // all the decls that targetDecl() considers it to reference 63 // Despite the name, these cases actually test allTargetDecls() for brevity. 64 class TargetDeclTest : public ::testing::Test { 65 protected: 66 using Rel = DeclRelation; 67 std::string Code; 68 std::vector<std::string> Flags; 69 70 // Asserts that `Code` has a marked selection of a node `NodeType`, 71 // and returns allTargetDecls() as PrintedDecl structs. 72 // Use via EXPECT_DECLS(). 73 std::vector<PrintedDecl> assertNodeAndPrintDecls(const char *NodeType) { 74 llvm::Annotations A(Code); 75 auto TU = TestTU::withCode(A.code()); 76 TU.ExtraArgs = Flags; 77 auto AST = TU.build(); 78 llvm::Annotations::Range R = A.range(); 79 auto Selection = SelectionTree::createRight( 80 AST.getASTContext(), AST.getTokens(), R.Begin, R.End); 81 const SelectionTree::Node *N = Selection.commonAncestor(); 82 if (!N) { 83 ADD_FAILURE() << "No node selected!\n" << Code; 84 return {}; 85 } 86 EXPECT_EQ(N->kind(), NodeType) << Selection; 87 88 std::vector<PrintedDecl> ActualDecls; 89 for (const auto &Entry : 90 allTargetDecls(N->ASTNode, AST.getHeuristicResolver())) 91 ActualDecls.emplace_back(Entry.first, Entry.second); 92 return ActualDecls; 93 } 94 }; 95 96 // This is a macro to preserve line numbers in assertion failures. 97 // It takes the expected decls as varargs to work around comma-in-macro issues. 98 #define EXPECT_DECLS(NodeType, ...) \ 99 EXPECT_THAT(assertNodeAndPrintDecls(NodeType), \ 100 ::testing::UnorderedElementsAreArray( \ 101 std::vector<PrintedDecl>({__VA_ARGS__}))) \ 102 << Code 103 using ExpectedDecls = std::vector<PrintedDecl>; 104 105 TEST_F(TargetDeclTest, Exprs) { 106 Code = R"cpp( 107 int f(); 108 int x = [[f]](); 109 )cpp"; 110 EXPECT_DECLS("DeclRefExpr", "int f()"); 111 112 Code = R"cpp( 113 struct S { S operator+(S) const; }; 114 auto X = S() [[+]] S(); 115 )cpp"; 116 EXPECT_DECLS("DeclRefExpr", "S operator+(S) const"); 117 118 Code = R"cpp( 119 int foo(); 120 int s = foo[[()]]; 121 )cpp"; 122 EXPECT_DECLS("CallExpr", "int foo()"); 123 124 Code = R"cpp( 125 struct X { 126 void operator()(int n); 127 }; 128 void test() { 129 X x; 130 x[[(123)]]; 131 } 132 )cpp"; 133 EXPECT_DECLS("CXXOperatorCallExpr", "void operator()(int n)"); 134 135 Code = R"cpp( 136 void test() { 137 goto [[label]]; 138 label: 139 return; 140 } 141 )cpp"; 142 EXPECT_DECLS("GotoStmt", "label:"); 143 Code = R"cpp( 144 void test() { 145 [[label]]: 146 return; 147 } 148 )cpp"; 149 EXPECT_DECLS("LabelStmt", "label:"); 150 } 151 152 TEST_F(TargetDeclTest, RecoveryForC) { 153 Flags = {"-xc", "-Xclang", "-frecovery-ast"}; 154 Code = R"cpp( 155 // error-ok: testing behavior on broken code 156 // int f(); 157 int f(int); 158 int x = [[f]](); 159 )cpp"; 160 EXPECT_DECLS("DeclRefExpr", "int f(int)"); 161 } 162 163 TEST_F(TargetDeclTest, Recovery) { 164 Code = R"cpp( 165 // error-ok: testing behavior on broken code 166 int f(); 167 int f(int, int); 168 int x = [[f]](42); 169 )cpp"; 170 EXPECT_DECLS("UnresolvedLookupExpr", "int f()", "int f(int, int)"); 171 } 172 173 TEST_F(TargetDeclTest, RecoveryType) { 174 Code = R"cpp( 175 // error-ok: testing behavior on broken code 176 struct S { int member; }; 177 S overloaded(int); 178 void foo() { 179 // No overload matches, but we have recovery-expr with the correct type. 180 overloaded().[[member]]; 181 } 182 )cpp"; 183 EXPECT_DECLS("MemberExpr", "int member"); 184 } 185 186 TEST_F(TargetDeclTest, UsingDecl) { 187 Code = R"cpp( 188 namespace foo { 189 int f(int); 190 int f(char); 191 } 192 using foo::f; 193 int x = [[f]](42); 194 )cpp"; 195 // f(char) is not referenced! 196 EXPECT_DECLS("DeclRefExpr", {"using foo::f", Rel::Alias}, {"int f(int)"}); 197 198 Code = R"cpp( 199 namespace foo { 200 int f(int); 201 int f(char); 202 } 203 [[using foo::f]]; 204 )cpp"; 205 // All overloads are referenced. 206 EXPECT_DECLS("UsingDecl", {"using foo::f", Rel::Alias}, {"int f(int)"}, 207 {"int f(char)"}); 208 209 Code = R"cpp( 210 struct X { 211 int foo(); 212 }; 213 struct Y : X { 214 using X::foo; 215 }; 216 int x = Y().[[foo]](); 217 )cpp"; 218 EXPECT_DECLS("MemberExpr", {"using X::foo", Rel::Alias}, {"int foo()"}); 219 220 Code = R"cpp( 221 template <typename T> 222 struct Base { 223 void waldo() {} 224 }; 225 template <typename T> 226 struct Derived : Base<T> { 227 using Base<T>::[[waldo]]; 228 }; 229 )cpp"; 230 EXPECT_DECLS("UnresolvedUsingValueDecl", {"using Base<T>::waldo", Rel::Alias}, 231 {"void waldo()"}); 232 233 Code = R"cpp( 234 namespace ns { 235 template<typename T> class S {}; 236 } 237 238 using ns::S; 239 240 template<typename T> 241 using A = [[S]]<T>; 242 )cpp"; 243 EXPECT_DECLS("TemplateSpecializationTypeLoc", {"using ns::S", Rel::Alias}, 244 {"template <typename T> class S"}, 245 {"class S", Rel::TemplatePattern}); 246 247 Code = R"cpp( 248 namespace ns { 249 template<typename T> class S {}; 250 } 251 252 using ns::S; 253 template <template <typename> class T> class X {}; 254 using B = X<[[S]]>; 255 )cpp"; 256 EXPECT_DECLS("TemplateArgumentLoc", {"using ns::S", Rel::Alias}, 257 {"template <typename T> class S"}); 258 259 Code = R"cpp( 260 namespace ns { 261 template<typename T> class S { public: S(T); }; 262 } 263 264 using ns::S; 265 [[S]] s(123); 266 )cpp"; 267 Flags.push_back("-std=c++17"); // For CTAD feature. 268 EXPECT_DECLS("DeducedTemplateSpecializationTypeLoc", 269 {"using ns::S", Rel::Alias}, {"template <typename T> class S"}, 270 {"class S", Rel::TemplatePattern}); 271 272 Code = R"cpp( 273 template<typename T> 274 class Foo { public: class foo {}; }; 275 template <class T> class A : public Foo<T> { 276 using typename Foo<T>::foo; 277 [[foo]] abc; 278 }; 279 )cpp"; 280 EXPECT_DECLS("UnresolvedUsingTypeLoc", 281 {"using typename Foo<T>::foo", Rel::Alias}); 282 283 // Using enum. 284 Flags.push_back("-std=c++20"); 285 Code = R"cpp( 286 namespace ns { enum class A { X }; } 287 [[using enum ns::A]]; 288 )cpp"; 289 EXPECT_DECLS("UsingEnumDecl", "enum class A : int"); 290 291 Code = R"cpp( 292 namespace ns { enum class A { X }; } 293 using enum ns::A; 294 auto m = [[X]]; 295 )cpp"; 296 EXPECT_DECLS("DeclRefExpr", "X"); 297 } 298 299 TEST_F(TargetDeclTest, BaseSpecifier) { 300 Code = R"cpp( 301 struct X {}; 302 struct Y : [[private]] X {}; 303 )cpp"; 304 EXPECT_DECLS("CXXBaseSpecifier", "struct X"); 305 Code = R"cpp( 306 struct X {}; 307 struct Y : [[private X]] {}; 308 )cpp"; 309 EXPECT_DECLS("CXXBaseSpecifier", "struct X"); 310 Code = R"cpp( 311 struct X {}; 312 struct Y : private [[X]] {}; 313 )cpp"; 314 EXPECT_DECLS("RecordTypeLoc", "struct X"); 315 } 316 317 TEST_F(TargetDeclTest, ConstructorInitList) { 318 Code = R"cpp( 319 struct X { 320 int a; 321 X() : [[a]](42) {} 322 }; 323 )cpp"; 324 EXPECT_DECLS("CXXCtorInitializer", "int a"); 325 326 Code = R"cpp( 327 struct X { 328 X() : [[X]](1) {} 329 X(int); 330 }; 331 )cpp"; 332 EXPECT_DECLS("RecordTypeLoc", "struct X"); 333 } 334 335 TEST_F(TargetDeclTest, DesignatedInit) { 336 Flags = {"-xc"}; // array designators are a C99 extension. 337 Code = R"c( 338 struct X { int a; }; 339 struct Y { int b; struct X c[2]; }; 340 struct Y y = { .c[0].[[a]] = 1 }; 341 )c"; 342 EXPECT_DECLS("DesignatedInitExpr", "int a"); 343 } 344 345 TEST_F(TargetDeclTest, NestedNameSpecifier) { 346 Code = R"cpp( 347 namespace a { namespace b { int c; } } 348 int x = a::[[b::]]c; 349 )cpp"; 350 EXPECT_DECLS("NestedNameSpecifierLoc", "namespace b"); 351 352 Code = R"cpp( 353 namespace a { struct X { enum { y }; }; } 354 int x = a::[[X::]]y; 355 )cpp"; 356 EXPECT_DECLS("NestedNameSpecifierLoc", "struct X"); 357 358 Code = R"cpp( 359 template <typename T> 360 int x = [[T::]]y; 361 )cpp"; 362 EXPECT_DECLS("NestedNameSpecifierLoc", "typename T"); 363 364 Code = R"cpp( 365 namespace a { int x; } 366 namespace b = a; 367 int y = [[b]]::x; 368 )cpp"; 369 EXPECT_DECLS("NestedNameSpecifierLoc", {"namespace b = a", Rel::Alias}, 370 {"namespace a", Rel::Underlying}); 371 } 372 373 TEST_F(TargetDeclTest, Types) { 374 Code = R"cpp( 375 struct X{}; 376 [[X]] x; 377 )cpp"; 378 EXPECT_DECLS("RecordTypeLoc", "struct X"); 379 380 Code = R"cpp( 381 struct S{}; 382 typedef S X; 383 [[X]] x; 384 )cpp"; 385 EXPECT_DECLS("TypedefTypeLoc", {"typedef S X", Rel::Alias}, 386 {"struct S", Rel::Underlying}); 387 Code = R"cpp( 388 namespace ns { struct S{}; } 389 typedef ns::S X; 390 [[X]] x; 391 )cpp"; 392 EXPECT_DECLS("TypedefTypeLoc", {"typedef ns::S X", Rel::Alias}, 393 {"struct S", Rel::Underlying}); 394 395 Code = R"cpp( 396 template<class T> 397 void foo() { [[T]] x; } 398 )cpp"; 399 EXPECT_DECLS("TemplateTypeParmTypeLoc", "class T"); 400 Flags.clear(); 401 402 Code = R"cpp( 403 template<template<typename> class T> 404 void foo() { [[T<int>]] x; } 405 )cpp"; 406 EXPECT_DECLS("TemplateSpecializationTypeLoc", "template <typename> class T"); 407 Flags.clear(); 408 409 Code = R"cpp( 410 template<template<typename> class ...T> 411 class C { 412 C<[[T...]]> foo; 413 }; 414 )cpp"; 415 EXPECT_DECLS("TemplateArgumentLoc", {"template <typename> class ...T"}); 416 Flags.clear(); 417 418 Code = R"cpp( 419 struct S{}; 420 S X; 421 [[decltype]](X) Y; 422 )cpp"; 423 EXPECT_DECLS("DecltypeTypeLoc", {"struct S", Rel::Underlying}); 424 425 Code = R"cpp( 426 struct S{}; 427 [[auto]] X = S{}; 428 )cpp"; 429 // FIXME: deduced type missing in AST. https://llvm.org/PR42914 430 EXPECT_DECLS("AutoTypeLoc", ); 431 432 Code = R"cpp( 433 template <typename... E> 434 struct S { 435 static const int size = sizeof...([[E]]); 436 }; 437 )cpp"; 438 EXPECT_DECLS("SizeOfPackExpr", "typename ...E"); 439 440 Code = R"cpp( 441 template <typename T> 442 class Foo { 443 void f([[Foo]] x); 444 }; 445 )cpp"; 446 EXPECT_DECLS("InjectedClassNameTypeLoc", "class Foo"); 447 } 448 449 TEST_F(TargetDeclTest, ClassTemplate) { 450 Code = R"cpp( 451 // Implicit specialization. 452 template<int x> class Foo{}; 453 [[Foo<42>]] B; 454 )cpp"; 455 EXPECT_DECLS("TemplateSpecializationTypeLoc", 456 {"template<> class Foo<42>", Rel::TemplateInstantiation}, 457 {"class Foo", Rel::TemplatePattern}); 458 459 Code = R"cpp( 460 template<typename T> class Foo {}; 461 // The "Foo<int>" SpecializationDecl is incomplete, there is no 462 // instantiation happening. 463 void func([[Foo<int>]] *); 464 )cpp"; 465 EXPECT_DECLS("TemplateSpecializationTypeLoc", 466 {"class Foo", Rel::TemplatePattern}, 467 {"template<> class Foo<int>", Rel::TemplateInstantiation}); 468 469 Code = R"cpp( 470 // Explicit specialization. 471 template<int x> class Foo{}; 472 template<> class Foo<42>{}; 473 [[Foo<42>]] B; 474 )cpp"; 475 EXPECT_DECLS("TemplateSpecializationTypeLoc", "template<> class Foo<42>"); 476 477 Code = R"cpp( 478 // Partial specialization. 479 template<typename T> class Foo{}; 480 template<typename T> class Foo<T*>{}; 481 [[Foo<int*>]] B; 482 )cpp"; 483 EXPECT_DECLS("TemplateSpecializationTypeLoc", 484 {"template<> class Foo<int *>", Rel::TemplateInstantiation}, 485 {"template <typename T> class Foo<T *>", Rel::TemplatePattern}); 486 487 Code = R"cpp( 488 // Template template argument. 489 template<typename T> struct Vector {}; 490 template <template <typename> class Container> 491 struct A {}; 492 A<[[Vector]]> a; 493 )cpp"; 494 EXPECT_DECLS("TemplateArgumentLoc", {"template <typename T> struct Vector"}); 495 496 Flags.push_back("-std=c++17"); // for CTAD tests 497 498 Code = R"cpp( 499 // Class template argument deduction 500 template <typename T> 501 struct Test { 502 Test(T); 503 }; 504 void foo() { 505 [[Test]] a(5); 506 } 507 )cpp"; 508 EXPECT_DECLS("DeducedTemplateSpecializationTypeLoc", 509 {"struct Test", Rel::TemplatePattern}); 510 511 Code = R"cpp( 512 // Deduction guide 513 template <typename T> 514 struct Test { 515 template <typename I> 516 Test(I, I); 517 }; 518 template <typename I> 519 [[Test]](I, I) -> Test<typename I::type>; 520 )cpp"; 521 EXPECT_DECLS("CXXDeductionGuideDecl", {"template <typename T> struct Test"}); 522 } 523 524 TEST_F(TargetDeclTest, Concept) { 525 Flags.push_back("-std=c++20"); 526 527 // FIXME: Should we truncate the pretty-printed form of a concept decl 528 // somewhere? 529 530 Code = R"cpp( 531 template <typename T> 532 concept Fooable = requires (T t) { t.foo(); }; 533 534 template <typename T> requires [[Fooable]]<T> 535 void bar(T t) { 536 t.foo(); 537 } 538 )cpp"; 539 EXPECT_DECLS( 540 "ConceptReference", 541 {"template <typename T> concept Fooable = requires (T t) { t.foo(); }"}); 542 543 // trailing requires clause 544 Code = R"cpp( 545 template <typename T> 546 concept Fooable = true; 547 548 template <typename T> 549 void foo() requires [[Fooable]]<T>; 550 )cpp"; 551 EXPECT_DECLS("ConceptReference", 552 {"template <typename T> concept Fooable = true"}); 553 554 // constrained-parameter 555 Code = R"cpp( 556 template <typename T> 557 concept Fooable = true; 558 559 template <[[Fooable]] T> 560 void bar(T t); 561 )cpp"; 562 EXPECT_DECLS("ConceptReference", 563 {"template <typename T> concept Fooable = true"}); 564 565 // partial-concept-id 566 Code = R"cpp( 567 template <typename T, typename U> 568 concept Fooable = true; 569 570 template <[[Fooable]]<int> T> 571 void bar(T t); 572 )cpp"; 573 EXPECT_DECLS("ConceptReference", 574 {"template <typename T, typename U> concept Fooable = true"}); 575 } 576 577 TEST_F(TargetDeclTest, Coroutine) { 578 Flags.push_back("-std=c++20"); 579 580 Code = R"cpp( 581 namespace std { 582 template <typename, typename...> struct coroutine_traits; 583 template <typename> struct coroutine_handle { 584 template <typename U> 585 coroutine_handle(coroutine_handle<U>&&) noexcept; 586 static coroutine_handle from_address(void* __addr) noexcept; 587 }; 588 } // namespace std 589 590 struct executor {}; 591 struct awaitable {}; 592 struct awaitable_frame { 593 awaitable get_return_object(); 594 void return_void(); 595 void unhandled_exception(); 596 struct result_t { 597 ~result_t(); 598 bool await_ready() const noexcept; 599 void await_suspend(std::coroutine_handle<void>) noexcept; 600 void await_resume() const noexcept; 601 }; 602 result_t initial_suspend() noexcept; 603 result_t final_suspend() noexcept; 604 result_t await_transform(executor) noexcept; 605 }; 606 607 namespace std { 608 template <> 609 struct coroutine_traits<awaitable> { 610 typedef awaitable_frame promise_type; 611 }; 612 } // namespace std 613 614 awaitable foo() { 615 co_await [[executor]](); 616 } 617 )cpp"; 618 EXPECT_DECLS("RecordTypeLoc", "struct executor"); 619 } 620 621 TEST_F(TargetDeclTest, RewrittenBinaryOperator) { 622 Flags.push_back("-std=c++20"); 623 624 Code = R"cpp( 625 namespace std { 626 struct strong_ordering { 627 int n; 628 constexpr operator int() const { return n; } 629 static const strong_ordering equal, greater, less; 630 }; 631 constexpr strong_ordering strong_ordering::equal = {0}; 632 constexpr strong_ordering strong_ordering::greater = {1}; 633 constexpr strong_ordering strong_ordering::less = {-1}; 634 } 635 636 struct Foo 637 { 638 int x; 639 auto operator<=>(const Foo&) const = default; 640 }; 641 642 bool x = (Foo(1) [[!=]] Foo(2)); 643 )cpp"; 644 EXPECT_DECLS("CXXRewrittenBinaryOperator", 645 {"bool operator==(const Foo &) const noexcept = default"}); 646 } 647 648 TEST_F(TargetDeclTest, FunctionTemplate) { 649 Code = R"cpp( 650 // Implicit specialization. 651 template<typename T> bool foo(T) { return false; }; 652 bool x = [[foo]](42); 653 )cpp"; 654 EXPECT_DECLS("DeclRefExpr", 655 {"template<> bool foo<int>(int)", Rel::TemplateInstantiation}, 656 {"bool foo(T)", Rel::TemplatePattern}); 657 658 Code = R"cpp( 659 // Explicit specialization. 660 template<typename T> bool foo(T) { return false; }; 661 template<> bool foo<int>(int) { return false; }; 662 bool x = [[foo]](42); 663 )cpp"; 664 EXPECT_DECLS("DeclRefExpr", "template<> bool foo<int>(int)"); 665 } 666 667 TEST_F(TargetDeclTest, VariableTemplate) { 668 // Pretty-printer doesn't do a very good job of variable templates :-( 669 Code = R"cpp( 670 // Implicit specialization. 671 template<typename T> int foo; 672 int x = [[foo]]<char>; 673 )cpp"; 674 EXPECT_DECLS("DeclRefExpr", {"int foo", Rel::TemplateInstantiation}, 675 {"int foo", Rel::TemplatePattern}); 676 677 Code = R"cpp( 678 // Explicit specialization. 679 template<typename T> int foo; 680 template <> bool foo<char>; 681 int x = [[foo]]<char>; 682 )cpp"; 683 EXPECT_DECLS("DeclRefExpr", "bool foo"); 684 685 Code = R"cpp( 686 // Partial specialization. 687 template<typename T> int foo; 688 template<typename T> bool foo<T*>; 689 bool x = [[foo]]<char*>; 690 )cpp"; 691 EXPECT_DECLS("DeclRefExpr", {"bool foo", Rel::TemplateInstantiation}, 692 {"bool foo", Rel::TemplatePattern}); 693 } 694 695 TEST_F(TargetDeclTest, TypeAliasTemplate) { 696 Code = R"cpp( 697 template<typename T, int X> class SmallVector {}; 698 template<typename U> using TinyVector = SmallVector<U, 1>; 699 [[TinyVector<int>]] X; 700 )cpp"; 701 EXPECT_DECLS("TemplateSpecializationTypeLoc", 702 {"template<> class SmallVector<int, 1>", 703 Rel::TemplateInstantiation | Rel::Underlying}, 704 {"class SmallVector", Rel::TemplatePattern | Rel::Underlying}, 705 {"using TinyVector = SmallVector<U, 1>", 706 Rel::Alias | Rel::TemplatePattern}); 707 } 708 709 TEST_F(TargetDeclTest, BuiltinTemplates) { 710 Code = R"cpp( 711 template <class T, T... Index> struct integer_sequence {}; 712 [[__make_integer_seq]]<integer_sequence, int, 3> X; 713 )cpp"; 714 EXPECT_DECLS( 715 "TemplateSpecializationTypeLoc", 716 {"struct integer_sequence", Rel::TemplatePattern | Rel::Underlying}, 717 {"template<> struct integer_sequence<int, <0, 1, 2>>", 718 Rel::TemplateInstantiation | Rel::Underlying}); 719 720 // Dependent context. 721 Code = R"cpp( 722 template <class T, T... Index> struct integer_sequence; 723 724 template <class T, int N> 725 using make_integer_sequence = [[__make_integer_seq]]<integer_sequence, T, N>; 726 )cpp"; 727 EXPECT_DECLS("TemplateSpecializationTypeLoc", ); 728 729 Code = R"cpp( 730 template <int N, class... Pack> 731 using type_pack_element = [[__type_pack_element]]<N, Pack...>; 732 )cpp"; 733 EXPECT_DECLS("TemplateSpecializationTypeLoc", ); 734 } 735 736 TEST_F(TargetDeclTest, MemberOfTemplate) { 737 Code = R"cpp( 738 template <typename T> struct Foo { 739 int x(T); 740 }; 741 int y = Foo<int>().[[x]](42); 742 )cpp"; 743 EXPECT_DECLS("MemberExpr", {"int x(int)", Rel::TemplateInstantiation}, 744 {"int x(T)", Rel::TemplatePattern}); 745 746 Code = R"cpp( 747 template <typename T> struct Foo { 748 template <typename U> 749 int x(T, U); 750 }; 751 int y = Foo<char>().[[x]]('c', 42); 752 )cpp"; 753 EXPECT_DECLS("MemberExpr", 754 {"template<> int x<int>(char, int)", Rel::TemplateInstantiation}, 755 {"int x(T, U)", Rel::TemplatePattern}); 756 } 757 758 TEST_F(TargetDeclTest, Lambda) { 759 Code = R"cpp( 760 void foo(int x = 42) { 761 auto l = [ [[x]] ]{ return x + 1; }; 762 }; 763 )cpp"; 764 EXPECT_DECLS("DeclRefExpr", "int x = 42"); 765 766 // It seems like this should refer to another var, with the outer param being 767 // an underlying decl. But it doesn't seem to exist. 768 Code = R"cpp( 769 void foo(int x = 42) { 770 auto l = [x]{ return [[x]] + 1; }; 771 }; 772 )cpp"; 773 EXPECT_DECLS("DeclRefExpr", "int x = 42"); 774 775 Code = R"cpp( 776 void foo() { 777 auto l = [x = 1]{ return [[x]] + 1; }; 778 }; 779 )cpp"; 780 // FIXME: why both auto and int? 781 EXPECT_DECLS("DeclRefExpr", "auto int x = 1"); 782 } 783 784 TEST_F(TargetDeclTest, OverloadExpr) { 785 Flags.push_back("--target=x86_64-pc-linux-gnu"); 786 787 Code = R"cpp( 788 void func(int*); 789 void func(char*); 790 791 template <class T> 792 void foo(T t) { 793 [[func]](t); 794 }; 795 )cpp"; 796 EXPECT_DECLS("UnresolvedLookupExpr", "void func(int *)", "void func(char *)"); 797 798 Code = R"cpp( 799 struct X { 800 void func(int*); 801 void func(char*); 802 }; 803 804 template <class T> 805 void foo(X x, T t) { 806 x.[[func]](t); 807 }; 808 )cpp"; 809 EXPECT_DECLS("UnresolvedMemberExpr", "void func(int *)", "void func(char *)"); 810 811 Code = R"cpp( 812 struct X { 813 static void *operator new(unsigned long); 814 }; 815 auto* k = [[new]] X(); 816 )cpp"; 817 EXPECT_DECLS("CXXNewExpr", "static void *operator new(unsigned long)"); 818 Code = R"cpp( 819 void *operator new(unsigned long); 820 auto* k = [[new]] int(); 821 )cpp"; 822 EXPECT_DECLS("CXXNewExpr", "void *operator new(unsigned long)"); 823 824 Code = R"cpp( 825 struct X { 826 static void operator delete(void *) noexcept; 827 }; 828 void k(X* x) { 829 [[delete]] x; 830 } 831 )cpp"; 832 EXPECT_DECLS("CXXDeleteExpr", "static void operator delete(void *) noexcept"); 833 Code = R"cpp( 834 void operator delete(void *) noexcept; 835 void k(int* x) { 836 [[delete]] x; 837 } 838 )cpp"; 839 // Sized deallocation is enabled by default in C++14 onwards. 840 EXPECT_DECLS("CXXDeleteExpr", 841 "void operator delete(void *, unsigned long) noexcept"); 842 } 843 844 TEST_F(TargetDeclTest, DependentExprs) { 845 Flags.push_back("--std=c++20"); 846 847 // Heuristic resolution of method of dependent field 848 Code = R"cpp( 849 struct A { void foo() {} }; 850 template <typename T> 851 struct B { 852 A a; 853 void bar() { 854 this->a.[[foo]](); 855 } 856 }; 857 )cpp"; 858 EXPECT_DECLS("MemberExpr", "void foo()"); 859 860 // Similar to above but base expression involves a function call. 861 Code = R"cpp( 862 struct A { 863 void foo() {} 864 }; 865 struct B { 866 A getA(); 867 }; 868 template <typename T> 869 struct C { 870 B c; 871 void bar() { 872 this->c.getA().[[foo]](); 873 } 874 }; 875 )cpp"; 876 EXPECT_DECLS("MemberExpr", "void foo()"); 877 878 // Similar to above but uses a function pointer. 879 Code = R"cpp( 880 struct A { 881 void foo() {} 882 }; 883 struct B { 884 using FPtr = A(*)(); 885 FPtr fptr; 886 }; 887 template <typename T> 888 struct C { 889 B c; 890 void bar() { 891 this->c.fptr().[[foo]](); 892 } 893 }; 894 )cpp"; 895 EXPECT_DECLS("MemberExpr", "void foo()"); 896 897 // Base expression involves a member access into this. 898 Code = R"cpp( 899 struct Bar { 900 int aaaa; 901 }; 902 template <typename T> struct Foo { 903 Bar func(int); 904 void test() { 905 func(1).[[aaaa]]; 906 } 907 }; 908 )cpp"; 909 EXPECT_DECLS("CXXDependentScopeMemberExpr", "int aaaa"); 910 911 Code = R"cpp( 912 class Foo { 913 public: 914 static Foo k(int); 915 template <typename T> T convert() const; 916 }; 917 template <typename T> 918 void test() { 919 Foo::k(T()).template [[convert]]<T>(); 920 } 921 )cpp"; 922 EXPECT_DECLS("CXXDependentScopeMemberExpr", 923 "template <typename T> T convert() const"); 924 925 Code = R"cpp( 926 template <typename T> 927 struct Waldo { 928 void find(); 929 }; 930 template <typename T> 931 using Wally = Waldo<T>; 932 template <typename T> 933 void foo(Wally<T> w) { 934 w.[[find]](); 935 } 936 )cpp"; 937 EXPECT_DECLS("CXXDependentScopeMemberExpr", "void find()"); 938 939 Code = R"cpp( 940 template <typename T> 941 struct Waldo { 942 void find(); 943 }; 944 template <typename T> 945 struct MetaWaldo { 946 using Type = Waldo<T>; 947 }; 948 template <typename T> 949 void foo(typename MetaWaldo<T>::Type w) { 950 w.[[find]](); 951 } 952 )cpp"; 953 EXPECT_DECLS("CXXDependentScopeMemberExpr", "void find()"); 954 955 Code = R"cpp( 956 struct Waldo { 957 void find(); 958 }; 959 template <typename T> 960 using Wally = Waldo; 961 template <typename> 962 struct S : Wally<int> { 963 void Foo() { this->[[find]](); } 964 }; 965 )cpp"; 966 EXPECT_DECLS("MemberExpr", "void find()"); 967 968 // Base expression is the type of a non-type template parameter 969 // which is deduced using CTAD. 970 Code = R"cpp( 971 template <int N> 972 struct Waldo { 973 const int found = N; 974 }; 975 976 template <Waldo W> 977 int test() { 978 return W.[[found]]; 979 } 980 )cpp"; 981 EXPECT_DECLS("CXXDependentScopeMemberExpr", "const int found = N"); 982 } 983 984 TEST_F(TargetDeclTest, DependentTypes) { 985 // Heuristic resolution of dependent type name 986 Code = R"cpp( 987 template <typename> 988 struct A { struct B {}; }; 989 990 template <typename T> 991 void foo(typename A<T>::[[B]]); 992 )cpp"; 993 EXPECT_DECLS("DependentNameTypeLoc", "struct B"); 994 995 // Heuristic resolution of dependent type name which doesn't get a TypeLoc 996 Code = R"cpp( 997 template <typename> 998 struct A { struct B { struct C {}; }; }; 999 1000 template <typename T> 1001 void foo(typename A<T>::[[B]]::C); 1002 )cpp"; 1003 EXPECT_DECLS("NestedNameSpecifierLoc", "struct B"); 1004 1005 // Heuristic resolution of dependent type name whose qualifier is also 1006 // dependent 1007 Code = R"cpp( 1008 template <typename> 1009 struct A { struct B { struct C {}; }; }; 1010 1011 template <typename T> 1012 void foo(typename A<T>::B::[[C]]); 1013 )cpp"; 1014 EXPECT_DECLS("DependentNameTypeLoc", "struct C"); 1015 1016 // Heuristic resolution of dependent template name 1017 Code = R"cpp( 1018 template <typename> 1019 struct A { 1020 template <typename> struct B {}; 1021 }; 1022 1023 template <typename T> 1024 void foo(typename A<T>::template [[B]]<int>); 1025 )cpp"; 1026 EXPECT_DECLS("DependentTemplateSpecializationTypeLoc", 1027 "template <typename> struct B"); 1028 1029 // Dependent name with recursive definition. We don't expect a 1030 // result, but we shouldn't get into a stack overflow either. 1031 Code = R"cpp( 1032 template <int N> 1033 struct waldo { 1034 typedef typename waldo<N - 1>::type::[[next]] type; 1035 }; 1036 )cpp"; 1037 EXPECT_DECLS("DependentNameTypeLoc", ); 1038 1039 // Similar to above but using mutually recursive templates. 1040 Code = R"cpp( 1041 template <int N> 1042 struct odd; 1043 1044 template <int N> 1045 struct even { 1046 using type = typename odd<N - 1>::type::next; 1047 }; 1048 1049 template <int N> 1050 struct odd { 1051 using type = typename even<N - 1>::type::[[next]]; 1052 }; 1053 )cpp"; 1054 EXPECT_DECLS("DependentNameTypeLoc", ); 1055 } 1056 1057 TEST_F(TargetDeclTest, TypedefCascade) { 1058 Code = R"cpp( 1059 struct C { 1060 using type = int; 1061 }; 1062 struct B { 1063 using type = C::type; 1064 }; 1065 struct A { 1066 using type = B::type; 1067 }; 1068 A::[[type]] waldo; 1069 )cpp"; 1070 EXPECT_DECLS("TypedefTypeLoc", 1071 {"using type = int", Rel::Alias | Rel::Underlying}, 1072 {"using type = C::type", Rel::Alias | Rel::Underlying}, 1073 {"using type = B::type", Rel::Alias}); 1074 } 1075 1076 TEST_F(TargetDeclTest, RecursiveTemplate) { 1077 Flags.push_back("-std=c++20"); // the test case uses concepts 1078 1079 Code = R"cpp( 1080 template <typename T> 1081 concept Leaf = false; 1082 1083 template <typename Tree> 1084 struct descend_left { 1085 using type = typename descend_left<typename Tree::left>::[[type]]; 1086 }; 1087 1088 template <Leaf Tree> 1089 struct descend_left<Tree> { 1090 using type = typename Tree::value; 1091 }; 1092 )cpp"; 1093 EXPECT_DECLS("DependentNameTypeLoc", 1094 {"using type = typename descend_left<typename Tree::left>::type", 1095 Rel::Alias | Rel::Underlying}); 1096 } 1097 1098 TEST_F(TargetDeclTest, ObjC) { 1099 Flags = {"-xobjective-c"}; 1100 Code = R"cpp( 1101 @interface Foo {} 1102 -(void)bar; 1103 @end 1104 void test(Foo *f) { 1105 [f [[bar]] ]; 1106 } 1107 )cpp"; 1108 EXPECT_DECLS("ObjCMessageExpr", "- (void)bar"); 1109 1110 Code = R"cpp( 1111 @interface Foo { @public int bar; } 1112 @end 1113 int test(Foo *f) { 1114 return [[f->bar]]; 1115 } 1116 )cpp"; 1117 EXPECT_DECLS("ObjCIvarRefExpr", "int bar"); 1118 1119 Code = R"cpp( 1120 @interface Foo {} 1121 -(int) x; 1122 -(void) setX:(int)x; 1123 @end 1124 void test(Foo *f) { 1125 [[f.x]] = 42; 1126 } 1127 )cpp"; 1128 EXPECT_DECLS("ObjCPropertyRefExpr", "- (void)setX:(int)x"); 1129 1130 Code = R"cpp( 1131 @interface I {} 1132 @property(retain) I* x; 1133 @property(retain) I* y; 1134 @end 1135 void test(I *f) { 1136 [[f.x]].y = 0; 1137 } 1138 )cpp"; 1139 EXPECT_DECLS("ObjCPropertyRefExpr", 1140 "@property(atomic, retain, readwrite) I *x"); 1141 1142 Code = R"cpp( 1143 @interface MYObject 1144 @end 1145 @interface Interface 1146 @property(retain) [[MYObject]] *x; 1147 @end 1148 )cpp"; 1149 EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface MYObject"); 1150 1151 Code = R"cpp( 1152 @interface MYObject2 1153 @end 1154 @interface Interface 1155 @property(retain, nonnull) [[MYObject2]] *x; 1156 @end 1157 )cpp"; 1158 EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface MYObject2"); 1159 1160 Code = R"cpp( 1161 @protocol Foo 1162 @end 1163 id test() { 1164 return [[@protocol(Foo)]]; 1165 } 1166 )cpp"; 1167 EXPECT_DECLS("ObjCProtocolExpr", "@protocol Foo"); 1168 1169 Code = R"cpp( 1170 @interface Foo 1171 @end 1172 void test([[Foo]] *p); 1173 )cpp"; 1174 EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface Foo"); 1175 1176 Code = R"cpp(// Don't consider implicit interface as the target. 1177 @implementation [[Implicit]] 1178 @end 1179 )cpp"; 1180 EXPECT_DECLS("ObjCImplementationDecl", "@implementation Implicit"); 1181 1182 Code = R"cpp( 1183 @interface Foo 1184 @end 1185 @implementation [[Foo]] 1186 @end 1187 )cpp"; 1188 EXPECT_DECLS("ObjCImplementationDecl", "@interface Foo"); 1189 1190 Code = R"cpp( 1191 @interface Foo 1192 @end 1193 @interface Foo (Ext) 1194 @end 1195 @implementation [[Foo]] (Ext) 1196 @end 1197 )cpp"; 1198 EXPECT_DECLS("ObjCCategoryImplDecl", "@interface Foo(Ext)"); 1199 1200 Code = R"cpp( 1201 @interface Foo 1202 @end 1203 @interface Foo (Ext) 1204 @end 1205 @implementation Foo ([[Ext]]) 1206 @end 1207 )cpp"; 1208 EXPECT_DECLS("ObjCCategoryImplDecl", "@interface Foo(Ext)"); 1209 1210 Code = R"cpp( 1211 void test(id</*error-ok*/[[InvalidProtocol]]> p); 1212 )cpp"; 1213 EXPECT_DECLS("ParmVarDecl", "id p"); 1214 1215 Code = R"cpp( 1216 @class C; 1217 @protocol Foo 1218 @end 1219 void test([[C]]<Foo> *p); 1220 )cpp"; 1221 EXPECT_DECLS("ObjCInterfaceTypeLoc", "@class C;"); 1222 1223 Code = R"cpp( 1224 @class C; 1225 @protocol Foo 1226 @end 1227 void test(C<[[Foo]]> *p); 1228 )cpp"; 1229 EXPECT_DECLS("ObjCProtocolLoc", "@protocol Foo"); 1230 1231 Code = R"cpp( 1232 @class C; 1233 @protocol Foo 1234 @end 1235 @protocol Bar 1236 @end 1237 void test(C<[[Foo]], Bar> *p); 1238 )cpp"; 1239 EXPECT_DECLS("ObjCProtocolLoc", "@protocol Foo"); 1240 1241 Code = R"cpp( 1242 @class C; 1243 @protocol Foo 1244 @end 1245 @protocol Bar 1246 @end 1247 void test(C<Foo, [[Bar]]> *p); 1248 )cpp"; 1249 EXPECT_DECLS("ObjCProtocolLoc", "@protocol Bar"); 1250 1251 Code = R"cpp( 1252 @interface Foo 1253 + (id)sharedInstance; 1254 @end 1255 @implementation Foo 1256 + (id)sharedInstance { return 0; } 1257 @end 1258 void test() { 1259 id value = [[Foo]].sharedInstance; 1260 } 1261 )cpp"; 1262 EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface Foo"); 1263 1264 Code = R"cpp( 1265 @interface Foo 1266 + (id)sharedInstance; 1267 @end 1268 @implementation Foo 1269 + (id)sharedInstance { return 0; } 1270 @end 1271 void test() { 1272 id value = Foo.[[sharedInstance]]; 1273 } 1274 )cpp"; 1275 EXPECT_DECLS("ObjCPropertyRefExpr", "+ (id)sharedInstance"); 1276 1277 Code = R"cpp( 1278 @interface Foo 1279 + ([[id]])sharedInstance; 1280 @end 1281 )cpp"; 1282 EXPECT_DECLS("TypedefTypeLoc", ); 1283 1284 Code = R"cpp( 1285 @interface Foo 1286 + ([[instancetype]])sharedInstance; 1287 @end 1288 )cpp"; 1289 EXPECT_DECLS("TypedefTypeLoc", ); 1290 } 1291 1292 class FindExplicitReferencesTest : public ::testing::Test { 1293 protected: 1294 struct AllRefs { 1295 std::string AnnotatedCode; 1296 std::string DumpedReferences; 1297 }; 1298 1299 TestTU newTU(llvm::StringRef Code) { 1300 TestTU TU; 1301 TU.Code = std::string(Code); 1302 1303 // FIXME: Auto-completion in a template requires disabling delayed template 1304 // parsing. 1305 TU.ExtraArgs.push_back("-std=c++20"); 1306 TU.ExtraArgs.push_back("-xobjective-c++"); 1307 1308 return TU; 1309 } 1310 1311 AllRefs annotatedReferences(llvm::StringRef Code, ParsedAST &AST, 1312 std::vector<ReferenceLoc> Refs) { 1313 auto &SM = AST.getSourceManager(); 1314 llvm::stable_sort(Refs, [&](const ReferenceLoc &L, const ReferenceLoc &R) { 1315 return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc); 1316 }); 1317 1318 std::string AnnotatedCode; 1319 unsigned NextCodeChar = 0; 1320 for (unsigned I = 0; I < Refs.size(); ++I) { 1321 auto &R = Refs[I]; 1322 1323 SourceLocation Pos = R.NameLoc; 1324 assert(Pos.isValid()); 1325 if (Pos.isMacroID()) // FIXME: figure out how to show macro locations. 1326 Pos = SM.getExpansionLoc(Pos); 1327 assert(Pos.isFileID()); 1328 1329 FileID File; 1330 unsigned Offset; 1331 std::tie(File, Offset) = SM.getDecomposedLoc(Pos); 1332 if (File == SM.getMainFileID()) { 1333 // Print the reference in a source code. 1334 assert(NextCodeChar <= Offset); 1335 AnnotatedCode += Code.substr(NextCodeChar, Offset - NextCodeChar); 1336 AnnotatedCode += "$" + std::to_string(I) + "^"; 1337 1338 NextCodeChar = Offset; 1339 } 1340 } 1341 AnnotatedCode += Code.substr(NextCodeChar); 1342 1343 std::string DumpedReferences; 1344 for (unsigned I = 0; I < Refs.size(); ++I) 1345 DumpedReferences += std::string(llvm::formatv("{0}: {1}\n", I, Refs[I])); 1346 1347 return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)}; 1348 } 1349 1350 /// Parses \p Code, and annotates its body with results of 1351 /// findExplicitReferences on all top level decls. 1352 /// See actual tests for examples of annotation format. 1353 AllRefs annotateAllReferences(llvm::StringRef Code) { 1354 TestTU TU = newTU(Code); 1355 auto AST = TU.build(); 1356 1357 std::vector<ReferenceLoc> Refs; 1358 for (auto *TopLevel : AST.getLocalTopLevelDecls()) 1359 findExplicitReferences( 1360 TopLevel, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); }, 1361 AST.getHeuristicResolver()); 1362 return annotatedReferences(Code, AST, std::move(Refs)); 1363 } 1364 1365 /// Parses \p Code, finds function or namespace '::foo' and annotates its body 1366 /// with results of findExplicitReferences. 1367 /// See actual tests for examples of annotation format. 1368 AllRefs annotateReferencesInFoo(llvm::StringRef Code) { 1369 TestTU TU = newTU(Code); 1370 auto AST = TU.build(); 1371 auto *TestDecl = &findDecl(AST, "foo"); 1372 if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl)) 1373 TestDecl = T->getTemplatedDecl(); 1374 1375 std::vector<ReferenceLoc> Refs; 1376 if (const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl)) 1377 findExplicitReferences( 1378 Func->getBody(), 1379 [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); }, 1380 AST.getHeuristicResolver()); 1381 else if (const auto *NS = llvm::dyn_cast<NamespaceDecl>(TestDecl)) 1382 findExplicitReferences( 1383 NS, 1384 [&Refs, &NS](ReferenceLoc R) { 1385 // Avoid adding the namespace foo decl to the results. 1386 if (R.Targets.size() == 1 && R.Targets.front() == NS) 1387 return; 1388 Refs.push_back(std::move(R)); 1389 }, 1390 AST.getHeuristicResolver()); 1391 else if (const auto *OC = llvm::dyn_cast<ObjCContainerDecl>(TestDecl)) 1392 findExplicitReferences( 1393 OC, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); }, 1394 AST.getHeuristicResolver()); 1395 else 1396 ADD_FAILURE() << "Failed to find ::foo decl for test"; 1397 1398 return annotatedReferences(Code, AST, std::move(Refs)); 1399 } 1400 }; 1401 1402 TEST_F(FindExplicitReferencesTest, AllRefsInFoo) { 1403 std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] = 1404 {// Simple expressions. 1405 {R"cpp( 1406 int global; 1407 int func(); 1408 void foo(int param) { 1409 $0^global = $1^param + $2^func(); 1410 } 1411 )cpp", 1412 "0: targets = {global}\n" 1413 "1: targets = {param}\n" 1414 "2: targets = {func}\n"}, 1415 {R"cpp( 1416 struct X { int a; }; 1417 void foo(X x) { 1418 $0^x.$1^a = 10; 1419 } 1420 )cpp", 1421 "0: targets = {x}\n" 1422 "1: targets = {X::a}\n"}, 1423 {R"cpp( 1424 // error-ok: testing with broken code 1425 int bar(); 1426 int foo() { 1427 return $0^bar() + $1^bar(42); 1428 } 1429 )cpp", 1430 "0: targets = {bar}\n" 1431 "1: targets = {bar}\n"}, 1432 // Namespaces and aliases. 1433 {R"cpp( 1434 namespace ns {} 1435 namespace alias = ns; 1436 void foo() { 1437 using namespace $0^ns; 1438 using namespace $1^alias; 1439 } 1440 )cpp", 1441 "0: targets = {ns}\n" 1442 "1: targets = {alias}\n"}, 1443 // Using declarations. 1444 {R"cpp( 1445 namespace ns { int global; } 1446 void foo() { 1447 using $0^ns::$1^global; 1448 } 1449 )cpp", 1450 "0: targets = {ns}\n" 1451 "1: targets = {ns::global}, qualifier = 'ns::'\n"}, 1452 // Using enum declarations. 1453 {R"cpp( 1454 namespace ns { enum class A {}; } 1455 void foo() { 1456 using enum $0^ns::$1^A; 1457 } 1458 )cpp", 1459 "0: targets = {ns}\n" 1460 "1: targets = {ns::A}, qualifier = 'ns::'\n"}, 1461 // Simple types. 1462 {R"cpp( 1463 struct Struct { int a; }; 1464 using Typedef = int; 1465 void foo() { 1466 $0^Struct $1^x; 1467 $2^Typedef $3^y; 1468 static_cast<$4^Struct*>(0); 1469 } 1470 )cpp", 1471 "0: targets = {Struct}\n" 1472 "1: targets = {x}, decl\n" 1473 "2: targets = {Typedef}\n" 1474 "3: targets = {y}, decl\n" 1475 "4: targets = {Struct}\n"}, 1476 // Name qualifiers. 1477 {R"cpp( 1478 namespace a { namespace b { struct S { typedef int type; }; } } 1479 void foo() { 1480 $0^a::$1^b::$2^S $3^x; 1481 using namespace $4^a::$5^b; 1482 $6^S::$7^type $8^y; 1483 } 1484 )cpp", 1485 "0: targets = {a}\n" 1486 "1: targets = {a::b}, qualifier = 'a::'\n" 1487 "2: targets = {a::b::S}, qualifier = 'a::b::'\n" 1488 "3: targets = {x}, decl\n" 1489 "4: targets = {a}\n" 1490 "5: targets = {a::b}, qualifier = 'a::'\n" 1491 "6: targets = {a::b::S}\n" 1492 "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n" 1493 "8: targets = {y}, decl\n"}, 1494 {R"cpp( 1495 void foo() { 1496 $0^ten: // PRINT "HELLO WORLD!" 1497 goto $1^ten; 1498 } 1499 )cpp", 1500 "0: targets = {ten}, decl\n" 1501 "1: targets = {ten}\n"}, 1502 // Simple templates. 1503 {R"cpp( 1504 template <class T> struct vector { using value_type = T; }; 1505 template <> struct vector<bool> { using value_type = bool; }; 1506 void foo() { 1507 $0^vector<int> $1^vi; 1508 $2^vector<bool> $3^vb; 1509 } 1510 )cpp", 1511 "0: targets = {vector<int>}\n" 1512 "1: targets = {vi}, decl\n" 1513 "2: targets = {vector<bool>}\n" 1514 "3: targets = {vb}, decl\n"}, 1515 // Template type aliases. 1516 {R"cpp( 1517 template <class T> struct vector { using value_type = T; }; 1518 template <> struct vector<bool> { using value_type = bool; }; 1519 template <class T> using valias = vector<T>; 1520 void foo() { 1521 $0^valias<int> $1^vi; 1522 $2^valias<bool> $3^vb; 1523 } 1524 )cpp", 1525 "0: targets = {valias}\n" 1526 "1: targets = {vi}, decl\n" 1527 "2: targets = {valias}\n" 1528 "3: targets = {vb}, decl\n"}, 1529 // Injected class name. 1530 {R"cpp( 1531 namespace foo { 1532 template <typename $0^T> 1533 class $1^Bar { 1534 ~$2^Bar(); 1535 void $3^f($4^Bar); 1536 }; 1537 } 1538 )cpp", 1539 "0: targets = {foo::Bar::T}, decl\n" 1540 "1: targets = {foo::Bar}, decl\n" 1541 "2: targets = {foo::Bar}\n" 1542 "3: targets = {foo::Bar::f}, decl\n" 1543 "4: targets = {foo::Bar}\n"}, 1544 // MemberExpr should know their using declaration. 1545 {R"cpp( 1546 struct X { void func(int); }; 1547 struct Y : X { 1548 using X::func; 1549 }; 1550 void foo(Y y) { 1551 $0^y.$1^func(1); 1552 } 1553 )cpp", 1554 "0: targets = {y}\n" 1555 "1: targets = {Y::func}\n"}, 1556 // DeclRefExpr should know their using declaration. 1557 {R"cpp( 1558 namespace ns { void bar(int); } 1559 using ns::bar; 1560 1561 void foo() { 1562 $0^bar(10); 1563 } 1564 )cpp", 1565 "0: targets = {bar}\n"}, 1566 // References from a macro. 1567 {R"cpp( 1568 #define FOO a 1569 #define BAR b 1570 1571 void foo(int a, int b) { 1572 $0^FOO+$1^BAR; 1573 } 1574 )cpp", 1575 "0: targets = {a}\n" 1576 "1: targets = {b}\n"}, 1577 // No references from implicit nodes. 1578 {R"cpp( 1579 struct vector { 1580 int *begin(); 1581 int *end(); 1582 }; 1583 1584 void foo() { 1585 for (int $0^x : $1^vector()) { 1586 $2^x = 10; 1587 } 1588 } 1589 )cpp", 1590 "0: targets = {x}, decl\n" 1591 "1: targets = {vector}\n" 1592 "2: targets = {x}\n"}, 1593 // Handle UnresolvedLookupExpr. 1594 {R"cpp( 1595 namespace ns1 { void func(char*); } 1596 namespace ns2 { void func(int*); } 1597 using namespace ns1; 1598 using namespace ns2; 1599 1600 template <class T> 1601 void foo(T t) { 1602 $0^func($1^t); 1603 } 1604 )cpp", 1605 "0: targets = {ns1::func, ns2::func}\n" 1606 "1: targets = {t}\n"}, 1607 // Handle UnresolvedMemberExpr. 1608 {R"cpp( 1609 struct X { 1610 void func(char*); 1611 void func(int*); 1612 }; 1613 1614 template <class T> 1615 void foo(X x, T t) { 1616 $0^x.$1^func($2^t); 1617 } 1618 )cpp", 1619 "0: targets = {x}\n" 1620 "1: targets = {X::func, X::func}\n" 1621 "2: targets = {t}\n"}, 1622 // Handle DependentScopeDeclRefExpr. 1623 {R"cpp( 1624 template <class T> 1625 struct S { 1626 static int value; 1627 }; 1628 1629 template <class T> 1630 void foo() { 1631 $0^S<$1^T>::$2^value; 1632 } 1633 )cpp", 1634 "0: targets = {S}\n" 1635 "1: targets = {T}\n" 1636 "2: targets = {S::value}, qualifier = 'S<T>::'\n"}, 1637 // Handle CXXDependentScopeMemberExpr. 1638 {R"cpp( 1639 template <class T> 1640 struct S { 1641 int value; 1642 }; 1643 1644 template <class T> 1645 void foo(S<T> t) { 1646 $0^t.$1^value; 1647 } 1648 )cpp", 1649 "0: targets = {t}\n" 1650 "1: targets = {S::value}\n"}, 1651 // Type template parameters. 1652 {R"cpp( 1653 template <class T> 1654 void foo() { 1655 static_cast<$0^T>(0); 1656 $1^T(); 1657 $2^T $3^t; 1658 } 1659 )cpp", 1660 "0: targets = {T}\n" 1661 "1: targets = {T}\n" 1662 "2: targets = {T}\n" 1663 "3: targets = {t}, decl\n"}, 1664 // Non-type template parameters. 1665 {R"cpp( 1666 template <int I> 1667 void foo() { 1668 int $0^x = $1^I; 1669 } 1670 )cpp", 1671 "0: targets = {x}, decl\n" 1672 "1: targets = {I}\n"}, 1673 // Template template parameters. 1674 {R"cpp( 1675 template <class T> struct vector {}; 1676 1677 template <template<class> class TT, template<class> class ...TP> 1678 void foo() { 1679 $0^TT<int> $1^x; 1680 $2^foo<$3^TT>(); 1681 $4^foo<$5^vector>(); 1682 $6^foo<$7^TP...>(); 1683 } 1684 )cpp", 1685 "0: targets = {TT}\n" 1686 "1: targets = {x}, decl\n" 1687 "2: targets = {foo}\n" 1688 "3: targets = {TT}\n" 1689 "4: targets = {foo}\n" 1690 "5: targets = {vector}\n" 1691 "6: targets = {foo}\n" 1692 "7: targets = {TP}\n"}, 1693 // Non-type template parameters with declarations. 1694 {R"cpp( 1695 int func(); 1696 template <int(*)()> struct wrapper {}; 1697 1698 template <int(*FuncParam)()> 1699 void foo() { 1700 $0^wrapper<$1^func> $2^w; 1701 $3^FuncParam(); 1702 } 1703 )cpp", 1704 "0: targets = {wrapper<&func>}\n" 1705 "1: targets = {func}\n" 1706 "2: targets = {w}, decl\n" 1707 "3: targets = {FuncParam}\n"}, 1708 // declaration references. 1709 {R"cpp( 1710 namespace ns {} 1711 class S {}; 1712 void foo() { 1713 class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; }; 1714 int $4^Var; 1715 enum $5^E { $6^ABC }; 1716 typedef int $7^INT; 1717 using $8^INT2 = int; 1718 namespace $9^NS = $10^ns; 1719 } 1720 )cpp", 1721 "0: targets = {Foo}, decl\n" 1722 "1: targets = {foo()::Foo::Foo}, decl\n" 1723 "2: targets = {Foo}\n" 1724 "3: targets = {foo()::Foo::field}, decl\n" 1725 "4: targets = {Var}, decl\n" 1726 "5: targets = {E}, decl\n" 1727 "6: targets = {foo()::ABC}, decl\n" 1728 "7: targets = {INT}, decl\n" 1729 "8: targets = {INT2}, decl\n" 1730 "9: targets = {NS}, decl\n" 1731 "10: targets = {ns}\n"}, 1732 // User-defined conversion operator. 1733 {R"cpp( 1734 void foo() { 1735 class $0^Bar {}; 1736 class $1^Foo { 1737 public: 1738 // FIXME: This should have only one reference to Bar. 1739 $2^operator $3^$4^Bar(); 1740 }; 1741 1742 $5^Foo $6^f; 1743 $7^f.$8^operator $9^Bar(); 1744 } 1745 )cpp", 1746 "0: targets = {Bar}, decl\n" 1747 "1: targets = {Foo}, decl\n" 1748 "2: targets = {foo()::Foo::operator Bar}, decl\n" 1749 "3: targets = {Bar}\n" 1750 "4: targets = {Bar}\n" 1751 "5: targets = {Foo}\n" 1752 "6: targets = {f}, decl\n" 1753 "7: targets = {f}\n" 1754 "8: targets = {foo()::Foo::operator Bar}\n" 1755 "9: targets = {Bar}\n"}, 1756 // Destructor. 1757 {R"cpp( 1758 void foo() { 1759 class $0^Foo { 1760 public: 1761 ~$1^Foo() {} 1762 1763 void $2^destructMe() { 1764 this->~$3^Foo(); 1765 } 1766 }; 1767 1768 $4^Foo $5^f; 1769 $6^f.~ /*...*/ $7^Foo(); 1770 } 1771 )cpp", 1772 "0: targets = {Foo}, decl\n" 1773 // FIXME: It's better to target destructor's FunctionDecl instead of 1774 // the type itself (similar to constructor). 1775 "1: targets = {Foo}\n" 1776 "2: targets = {foo()::Foo::destructMe}, decl\n" 1777 "3: targets = {Foo}\n" 1778 "4: targets = {Foo}\n" 1779 "5: targets = {f}, decl\n" 1780 "6: targets = {f}\n" 1781 "7: targets = {Foo}\n"}, 1782 // cxx constructor initializer. 1783 {R"cpp( 1784 class Base {}; 1785 void foo() { 1786 // member initializer 1787 class $0^X { 1788 int $1^abc; 1789 $2^X(): $3^abc() {} 1790 }; 1791 // base initializer 1792 class $4^Derived : public $5^Base { 1793 $6^Base $7^B; 1794 $8^Derived() : $9^Base() {} 1795 }; 1796 // delegating initializer 1797 class $10^Foo { 1798 $11^Foo(int); 1799 $12^Foo(): $13^Foo(111) {} 1800 }; 1801 } 1802 )cpp", 1803 "0: targets = {X}, decl\n" 1804 "1: targets = {foo()::X::abc}, decl\n" 1805 "2: targets = {foo()::X::X}, decl\n" 1806 "3: targets = {foo()::X::abc}\n" 1807 "4: targets = {Derived}, decl\n" 1808 "5: targets = {Base}\n" 1809 "6: targets = {Base}\n" 1810 "7: targets = {foo()::Derived::B}, decl\n" 1811 "8: targets = {foo()::Derived::Derived}, decl\n" 1812 "9: targets = {Base}\n" 1813 "10: targets = {Foo}, decl\n" 1814 "11: targets = {foo()::Foo::Foo}, decl\n" 1815 "12: targets = {foo()::Foo::Foo}, decl\n" 1816 "13: targets = {Foo}\n"}, 1817 // Anonymous entities should not be reported. 1818 { 1819 R"cpp( 1820 void foo() { 1821 $0^class {} $1^x; 1822 int (*$2^fptr)(int $3^a, int) = nullptr; 1823 } 1824 )cpp", 1825 "0: targets = {(unnamed)}\n" 1826 "1: targets = {x}, decl\n" 1827 "2: targets = {fptr}, decl\n" 1828 "3: targets = {a}, decl\n"}, 1829 // Namespace aliases should be handled properly. 1830 { 1831 R"cpp( 1832 namespace ns { struct Type {}; } 1833 namespace alias = ns; 1834 namespace rec_alias = alias; 1835 1836 void foo() { 1837 $0^ns::$1^Type $2^a; 1838 $3^alias::$4^Type $5^b; 1839 $6^rec_alias::$7^Type $8^c; 1840 } 1841 )cpp", 1842 "0: targets = {ns}\n" 1843 "1: targets = {ns::Type}, qualifier = 'ns::'\n" 1844 "2: targets = {a}, decl\n" 1845 "3: targets = {alias}\n" 1846 "4: targets = {ns::Type}, qualifier = 'alias::'\n" 1847 "5: targets = {b}, decl\n" 1848 "6: targets = {rec_alias}\n" 1849 "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n" 1850 "8: targets = {c}, decl\n"}, 1851 // Handle SizeOfPackExpr. 1852 { 1853 R"cpp( 1854 template <typename... E> 1855 void foo() { 1856 constexpr int $0^size = sizeof...($1^E); 1857 }; 1858 )cpp", 1859 "0: targets = {size}, decl\n" 1860 "1: targets = {E}\n"}, 1861 // Class template argument deduction 1862 { 1863 R"cpp( 1864 template <typename T> 1865 struct Test { 1866 Test(T); 1867 }; 1868 void foo() { 1869 $0^Test $1^a(5); 1870 } 1871 )cpp", 1872 "0: targets = {Test}\n" 1873 "1: targets = {a}, decl\n"}, 1874 // Templates 1875 {R"cpp( 1876 namespace foo { 1877 template <typename $0^T> 1878 class $1^Bar {}; 1879 } 1880 )cpp", 1881 "0: targets = {foo::Bar::T}, decl\n" 1882 "1: targets = {foo::Bar}, decl\n"}, 1883 // Templates 1884 {R"cpp( 1885 namespace foo { 1886 template <typename $0^T> 1887 void $1^func(); 1888 } 1889 )cpp", 1890 "0: targets = {T}, decl\n" 1891 "1: targets = {foo::func}, decl\n"}, 1892 // Templates 1893 {R"cpp( 1894 namespace foo { 1895 template <typename $0^T> 1896 $1^T $2^x; 1897 } 1898 )cpp", 1899 "0: targets = {foo::T}, decl\n" 1900 "1: targets = {foo::T}\n" 1901 "2: targets = {foo::x}, decl\n"}, 1902 // Templates 1903 {R"cpp( 1904 template<typename T> class vector {}; 1905 namespace foo { 1906 template <typename $0^T> 1907 using $1^V = $2^vector<$3^T>; 1908 } 1909 )cpp", 1910 "0: targets = {foo::T}, decl\n" 1911 "1: targets = {foo::V}, decl\n" 1912 "2: targets = {vector}\n" 1913 "3: targets = {foo::T}\n"}, 1914 // Concept 1915 { 1916 R"cpp( 1917 template <typename T> 1918 concept Drawable = requires (T t) { t.draw(); }; 1919 1920 namespace foo { 1921 template <typename $0^T> requires $1^Drawable<$2^T> 1922 void $3^bar($4^T $5^t) { 1923 $6^t.$7^draw(); 1924 } 1925 } 1926 )cpp", 1927 "0: targets = {T}, decl\n" 1928 "1: targets = {Drawable}\n" 1929 "2: targets = {T}\n" 1930 "3: targets = {foo::bar}, decl\n" 1931 "4: targets = {T}\n" 1932 "5: targets = {t}, decl\n" 1933 "6: targets = {t}\n" 1934 "7: targets = {}\n"}, 1935 // Objective-C: instance variables 1936 { 1937 R"cpp( 1938 @interface I { 1939 @public 1940 I *_z; 1941 } 1942 @end 1943 I *f; 1944 void foo() { 1945 $0^f->$1^_z = 0; 1946 } 1947 )cpp", 1948 "0: targets = {f}\n" 1949 "1: targets = {I::_z}\n"}, 1950 // Objective-C: properties 1951 { 1952 R"cpp( 1953 @interface I {} 1954 @property(retain) I* x; 1955 @property(retain) I* y; 1956 @end 1957 I *f; 1958 void foo() { 1959 $0^f.$1^x.$2^y = 0; 1960 } 1961 )cpp", 1962 "0: targets = {f}\n" 1963 "1: targets = {I::x}\n" 1964 "2: targets = {I::y}\n"}, 1965 // Objective-C: implicit properties 1966 { 1967 R"cpp( 1968 @interface I {} 1969 -(I*)x; 1970 -(void)setY:(I*)y; 1971 @end 1972 I *f; 1973 void foo() { 1974 $0^f.$1^x.$2^y = 0; 1975 } 1976 )cpp", 1977 "0: targets = {f}\n" 1978 "1: targets = {I::x}\n" 1979 "2: targets = {I::setY:}\n"}, 1980 // Objective-C: class properties 1981 { 1982 R"cpp( 1983 @interface I {} 1984 @property(class) I *x; 1985 @end 1986 id local; 1987 void foo() { 1988 $0^I.$1^x = 0; 1989 $2^local = $3^I.$4^x; 1990 } 1991 )cpp", 1992 "0: targets = {I}\n" 1993 "1: targets = {I::setX:}\n" 1994 "2: targets = {local}\n" 1995 "3: targets = {I}\n" 1996 "4: targets = {I::x}\n"}, 1997 // Objective-C: implicit class properties 1998 { 1999 R"cpp( 2000 @interface I {} 2001 +(I*)x; 2002 +(void)setX:(I*)x; 2003 @end 2004 id local; 2005 void foo() { 2006 $0^I.$1^x = 0; 2007 $2^local = $3^I.$4^x; 2008 } 2009 )cpp", 2010 "0: targets = {I}\n" 2011 "1: targets = {I::setX:}\n" 2012 "2: targets = {local}\n" 2013 "3: targets = {I}\n" 2014 "4: targets = {I::x}\n"}, 2015 {// Objective-C: methods 2016 R"cpp( 2017 @interface I 2018 -(void) a:(int)x b:(int)y; 2019 @end 2020 void foo(I *i) { 2021 [$0^i $1^a:1 b:2]; 2022 } 2023 )cpp", 2024 "0: targets = {i}\n" 2025 "1: targets = {I::a:b:}\n"}, 2026 {// Objective-C: protocols 2027 R"cpp( 2028 @interface I 2029 @end 2030 @protocol P 2031 @end 2032 void foo() { 2033 $0^I<$1^P> *$2^x; 2034 } 2035 )cpp", 2036 "0: targets = {I}\n" 2037 "1: targets = {P}\n" 2038 "2: targets = {x}, decl\n"}, 2039 2040 // Designated initializers. 2041 {R"cpp( 2042 void foo() { 2043 struct $0^Foo { 2044 int $1^Bar; 2045 }; 2046 $2^Foo $3^f { .$4^Bar = 42 }; 2047 } 2048 )cpp", 2049 "0: targets = {Foo}, decl\n" 2050 "1: targets = {foo()::Foo::Bar}, decl\n" 2051 "2: targets = {Foo}\n" 2052 "3: targets = {f}, decl\n" 2053 "4: targets = {foo()::Foo::Bar}\n"}, 2054 {R"cpp( 2055 void foo() { 2056 struct $0^Baz { 2057 int $1^Field; 2058 }; 2059 struct $2^Bar { 2060 $3^Baz $4^Foo; 2061 }; 2062 $5^Bar $6^bar { .$7^Foo.$8^Field = 42 }; 2063 } 2064 )cpp", 2065 "0: targets = {Baz}, decl\n" 2066 "1: targets = {foo()::Baz::Field}, decl\n" 2067 "2: targets = {Bar}, decl\n" 2068 "3: targets = {Baz}\n" 2069 "4: targets = {foo()::Bar::Foo}, decl\n" 2070 "5: targets = {Bar}\n" 2071 "6: targets = {bar}, decl\n" 2072 "7: targets = {foo()::Bar::Foo}\n" 2073 "8: targets = {foo()::Baz::Field}\n"}, 2074 {R"cpp( 2075 template<typename T> 2076 void crash(T); 2077 template<typename T> 2078 void foo() { 2079 $0^crash({.$1^x = $2^T()}); 2080 } 2081 )cpp", 2082 "0: targets = {crash}\n" 2083 "1: targets = {}\n" 2084 "2: targets = {T}\n"}, 2085 // unknown template name should not crash. 2086 {R"cpp( 2087 template <template <typename> typename T> 2088 struct Base {}; 2089 namespace foo { 2090 template <typename $0^T> 2091 struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {}; 2092 } 2093 )cpp", 2094 "0: targets = {foo::Derive::T}, decl\n" 2095 "1: targets = {foo::Derive}, decl\n" 2096 "2: targets = {Base}\n" 2097 "3: targets = {foo::Derive::T}\n" 2098 "4: targets = {}, qualifier = 'T::'\n"}, 2099 // deduction guide 2100 {R"cpp( 2101 namespace foo { 2102 template <typename $0^T> 2103 struct $1^Test { 2104 template <typename $2^I> 2105 $3^Test($4^I); 2106 }; 2107 template <typename $5^I> 2108 $6^Test($7^I) -> $8^Test<typename $9^I::$10^type>; 2109 } 2110 )cpp", 2111 "0: targets = {T}, decl\n" 2112 "1: targets = {foo::Test}, decl\n" 2113 "2: targets = {I}, decl\n" 2114 "3: targets = {foo::Test::Test<T>}, decl\n" 2115 "4: targets = {I}\n" 2116 "5: targets = {I}, decl\n" 2117 "6: targets = {foo::Test}\n" 2118 "7: targets = {I}\n" 2119 "8: targets = {foo::Test}\n" 2120 "9: targets = {I}\n" 2121 "10: targets = {}, qualifier = 'I::'\n"}}; 2122 2123 for (const auto &C : Cases) { 2124 llvm::StringRef ExpectedCode = C.first; 2125 llvm::StringRef ExpectedRefs = C.second; 2126 2127 auto Actual = 2128 annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code()); 2129 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode); 2130 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode; 2131 } 2132 } 2133 2134 TEST_F(FindExplicitReferencesTest, AllRefs) { 2135 std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] = 2136 {{R"cpp( 2137 @interface $0^MyClass 2138 @end 2139 @implementation $1^$2^MyClass 2140 @end 2141 )cpp", 2142 "0: targets = {MyClass}, decl\n" 2143 "1: targets = {MyClass}\n" 2144 "2: targets = {MyClass}, decl\n"}, 2145 {R"cpp( 2146 @interface $0^MyClass 2147 @end 2148 @interface $1^MyClass ($2^Category) 2149 @end 2150 @implementation $3^MyClass ($4^$5^Category) 2151 @end 2152 )cpp", 2153 "0: targets = {MyClass}, decl\n" 2154 "1: targets = {MyClass}\n" 2155 "2: targets = {Category}, decl\n" 2156 "3: targets = {MyClass}\n" 2157 "4: targets = {Category}\n" 2158 "5: targets = {Category}, decl\n"}}; 2159 2160 for (const auto &C : Cases) { 2161 llvm::StringRef ExpectedCode = C.first; 2162 llvm::StringRef ExpectedRefs = C.second; 2163 2164 auto Actual = annotateAllReferences(llvm::Annotations(ExpectedCode).code()); 2165 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode); 2166 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode; 2167 } 2168 } 2169 2170 } // namespace 2171 } // namespace clangd 2172 } // namespace clang 2173