1 //===-- CodeCompleteTests.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 9 #include "Annotations.h" 10 #include "ClangdServer.h" 11 #include "CodeComplete.h" 12 #include "Compiler.h" 13 #include "Matchers.h" 14 #include "Protocol.h" 15 #include "Quality.h" 16 #include "SourceCode.h" 17 #include "SyncAPI.h" 18 #include "TestFS.h" 19 #include "TestIndex.h" 20 #include "TestTU.h" 21 #include "Threading.h" 22 #include "index/Index.h" 23 #include "index/MemIndex.h" 24 #include "clang/Sema/CodeCompleteConsumer.h" 25 #include "clang/Tooling/CompilationDatabase.h" 26 #include "llvm/Support/Error.h" 27 #include "llvm/Support/Path.h" 28 #include "llvm/Testing/Support/Error.h" 29 #include "gmock/gmock.h" 30 #include "gtest/gtest.h" 31 #include <condition_variable> 32 #include <mutex> 33 34 namespace clang { 35 namespace clangd { 36 37 namespace { 38 using ::llvm::Failed; 39 using ::testing::AllOf; 40 using ::testing::Contains; 41 using ::testing::ElementsAre; 42 using ::testing::Field; 43 using ::testing::HasSubstr; 44 using ::testing::IsEmpty; 45 using ::testing::Not; 46 using ::testing::UnorderedElementsAre; 47 48 class IgnoreDiagnostics : public DiagnosticsConsumer { 49 void onDiagnosticsReady(PathRef File, 50 std::vector<Diag> Diagnostics) override {} 51 }; 52 53 // GMock helpers for matching completion items. 54 MATCHER_P(Named, Name, "") { return arg.Name == Name; } 55 MATCHER_P(NameStartsWith, Prefix, "") { 56 return llvm::StringRef(arg.Name).startswith(Prefix); 57 } 58 MATCHER_P(Scope, S, "") { return arg.Scope == S; } 59 MATCHER_P(Qualifier, Q, "") { return arg.RequiredQualifier == Q; } 60 MATCHER_P(Labeled, Label, "") { 61 return arg.RequiredQualifier + arg.Name + arg.Signature == Label; 62 } 63 MATCHER_P(SigHelpLabeled, Label, "") { return arg.label == Label; } 64 MATCHER_P(Kind, K, "") { return arg.Kind == K; } 65 MATCHER_P(Doc, D, "") { return arg.Documentation == D; } 66 MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; } 67 MATCHER_P(HasInclude, IncludeHeader, "") { 68 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader; 69 } 70 MATCHER_P(InsertInclude, IncludeHeader, "") { 71 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader && 72 bool(arg.Includes[0].Insertion); 73 } 74 MATCHER(InsertInclude, "") { 75 return !arg.Includes.empty() && bool(arg.Includes[0].Insertion); 76 } 77 MATCHER_P(SnippetSuffix, Text, "") { return arg.SnippetSuffix == Text; } 78 MATCHER_P(Origin, OriginSet, "") { return arg.Origin == OriginSet; } 79 MATCHER_P(Signature, S, "") { return arg.Signature == S; } 80 81 // Shorthand for Contains(Named(Name)). 82 Matcher<const std::vector<CodeCompletion> &> Has(std::string Name) { 83 return Contains(Named(std::move(Name))); 84 } 85 Matcher<const std::vector<CodeCompletion> &> Has(std::string Name, 86 CompletionItemKind K) { 87 return Contains(AllOf(Named(std::move(Name)), Kind(K))); 88 } 89 MATCHER(IsDocumented, "") { return !arg.Documentation.empty(); } 90 MATCHER(Deprecated, "") { return arg.Deprecated; } 91 92 std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) { 93 SymbolSlab::Builder Slab; 94 for (const auto &Sym : Symbols) 95 Slab.insert(Sym); 96 return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab()); 97 } 98 99 CodeCompleteResult completions(ClangdServer &Server, llvm::StringRef TestCode, 100 Position Point, 101 std::vector<Symbol> IndexSymbols = {}, 102 clangd::CodeCompleteOptions Opts = {}) { 103 std::unique_ptr<SymbolIndex> OverrideIndex; 104 if (!IndexSymbols.empty()) { 105 assert(!Opts.Index && "both Index and IndexSymbols given!"); 106 OverrideIndex = memIndex(std::move(IndexSymbols)); 107 Opts.Index = OverrideIndex.get(); 108 } 109 110 auto File = testPath("foo.cpp"); 111 runAddDocument(Server, File, TestCode); 112 auto CompletionList = 113 llvm::cantFail(runCodeComplete(Server, File, Point, Opts)); 114 return CompletionList; 115 } 116 117 CodeCompleteResult completions(ClangdServer &Server, llvm::StringRef Text, 118 std::vector<Symbol> IndexSymbols = {}, 119 clangd::CodeCompleteOptions Opts = {}, 120 PathRef FilePath = "foo.cpp") { 121 std::unique_ptr<SymbolIndex> OverrideIndex; 122 if (!IndexSymbols.empty()) { 123 assert(!Opts.Index && "both Index and IndexSymbols given!"); 124 OverrideIndex = memIndex(std::move(IndexSymbols)); 125 Opts.Index = OverrideIndex.get(); 126 } 127 128 auto File = testPath(FilePath); 129 Annotations Test(Text); 130 runAddDocument(Server, File, Test.code()); 131 auto CompletionList = 132 llvm::cantFail(runCodeComplete(Server, File, Test.point(), Opts)); 133 return CompletionList; 134 } 135 136 // Builds a server and runs code completion. 137 // If IndexSymbols is non-empty, an index will be built and passed to opts. 138 CodeCompleteResult completions(llvm::StringRef Text, 139 std::vector<Symbol> IndexSymbols = {}, 140 clangd::CodeCompleteOptions Opts = {}, 141 PathRef FilePath = "foo.cpp") { 142 MockFSProvider FS; 143 MockCompilationDatabase CDB; 144 // To make sure our tests for completiopns inside templates work on Windows. 145 CDB.ExtraClangFlags = {"-fno-delayed-template-parsing"}; 146 IgnoreDiagnostics DiagConsumer; 147 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 148 return completions(Server, Text, std::move(IndexSymbols), std::move(Opts), 149 FilePath); 150 } 151 152 // Builds a server and runs code completion. 153 // If IndexSymbols is non-empty, an index will be built and passed to opts. 154 CodeCompleteResult completionsNoCompile(llvm::StringRef Text, 155 std::vector<Symbol> IndexSymbols = {}, 156 clangd::CodeCompleteOptions Opts = {}, 157 PathRef FilePath = "foo.cpp") { 158 std::unique_ptr<SymbolIndex> OverrideIndex; 159 if (!IndexSymbols.empty()) { 160 assert(!Opts.Index && "both Index and IndexSymbols given!"); 161 OverrideIndex = memIndex(std::move(IndexSymbols)); 162 Opts.Index = OverrideIndex.get(); 163 } 164 165 MockFSProvider FS; 166 Annotations Test(Text); 167 return codeComplete(FilePath, tooling::CompileCommand(), /*Preamble=*/nullptr, 168 Test.code(), Test.point(), FS.getFileSystem(), Opts); 169 } 170 171 Symbol withReferences(int N, Symbol S) { 172 S.References = N; 173 return S; 174 } 175 176 TEST(CompletionTest, Limit) { 177 clangd::CodeCompleteOptions Opts; 178 Opts.Limit = 2; 179 auto Results = completions(R"cpp( 180 struct ClassWithMembers { 181 int AAA(); 182 int BBB(); 183 int CCC(); 184 }; 185 186 int main() { ClassWithMembers().^ } 187 )cpp", 188 /*IndexSymbols=*/{}, Opts); 189 190 EXPECT_TRUE(Results.HasMore); 191 EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB"))); 192 } 193 194 TEST(CompletionTest, Filter) { 195 std::string Body = R"cpp( 196 #define MotorCar 197 int Car; 198 struct S { 199 int FooBar; 200 int FooBaz; 201 int Qux; 202 }; 203 )cpp"; 204 205 // Only items matching the fuzzy query are returned. 206 EXPECT_THAT(completions(Body + "int main() { S().Foba^ }").Completions, 207 AllOf(Has("FooBar"), Has("FooBaz"), Not(Has("Qux")))); 208 209 // Macros require prefix match. 210 EXPECT_THAT(completions(Body + "int main() { C^ }").Completions, 211 AllOf(Has("Car"), Not(Has("MotorCar")))); 212 } 213 214 void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) { 215 auto Results = completions( 216 R"cpp( 217 int global_var; 218 219 int global_func(); 220 221 // Make sure this is not in preamble. 222 #define MACRO X 223 224 struct GlobalClass {}; 225 226 struct ClassWithMembers { 227 /// Doc for method. 228 int method(); 229 230 int field; 231 private: 232 int private_field; 233 }; 234 235 int test() { 236 struct LocalClass {}; 237 238 /// Doc for local_var. 239 int local_var; 240 241 ClassWithMembers().^ 242 } 243 )cpp", 244 {cls("IndexClass"), var("index_var"), func("index_func")}, Opts); 245 246 EXPECT_TRUE(Results.RanParser); 247 // Class members. The only items that must be present in after-dot 248 // completion. 249 EXPECT_THAT(Results.Completions, 250 AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")), 251 Not(Has("operator=")), Not(Has("~ClassWithMembers")))); 252 EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions, 253 Has("private_field")); 254 // Global items. 255 EXPECT_THAT( 256 Results.Completions, 257 Not(AnyOf(Has("global_var"), Has("index_var"), Has("global_func"), 258 Has("global_func()"), Has("index_func"), Has("GlobalClass"), 259 Has("IndexClass"), Has("MACRO"), Has("LocalClass")))); 260 // There should be no code patterns (aka snippets) in after-dot 261 // completion. At least there aren't any we're aware of. 262 EXPECT_THAT(Results.Completions, 263 Not(Contains(Kind(CompletionItemKind::Snippet)))); 264 // Check documentation. 265 EXPECT_IFF(Opts.IncludeComments, Results.Completions, 266 Contains(IsDocumented())); 267 } 268 269 void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) { 270 auto Results = completions( 271 R"cpp( 272 int global_var; 273 int global_func(); 274 275 // Make sure this is not in preamble. 276 #define MACRO X 277 278 struct GlobalClass {}; 279 280 struct ClassWithMembers { 281 /// Doc for method. 282 int method(); 283 }; 284 285 int test() { 286 struct LocalClass {}; 287 288 /// Doc for local_var. 289 int local_var; 290 291 ^ 292 } 293 )cpp", 294 {cls("IndexClass"), var("index_var"), func("index_func")}, Opts); 295 296 EXPECT_TRUE(Results.RanParser); 297 // Class members. Should never be present in global completions. 298 EXPECT_THAT(Results.Completions, 299 Not(AnyOf(Has("method"), Has("method()"), Has("field")))); 300 // Global items. 301 EXPECT_THAT(Results.Completions, 302 AllOf(Has("global_var"), Has("index_var"), Has("global_func"), 303 Has("index_func" /* our fake symbol doesn't include () */), 304 Has("GlobalClass"), Has("IndexClass"))); 305 // A macro. 306 EXPECT_IFF(Opts.IncludeMacros, Results.Completions, Has("MACRO")); 307 // Local items. Must be present always. 308 EXPECT_THAT(Results.Completions, 309 AllOf(Has("local_var"), Has("LocalClass"), 310 Contains(Kind(CompletionItemKind::Snippet)))); 311 // Check documentation. 312 EXPECT_IFF(Opts.IncludeComments, Results.Completions, 313 Contains(IsDocumented())); 314 } 315 316 TEST(CompletionTest, CompletionOptions) { 317 auto Test = [&](const clangd::CodeCompleteOptions &Opts) { 318 testAfterDotCompletion(Opts); 319 testGlobalScopeCompletion(Opts); 320 }; 321 // We used to test every combination of options, but that got too slow (2^N). 322 auto Flags = { 323 &clangd::CodeCompleteOptions::IncludeMacros, 324 &clangd::CodeCompleteOptions::IncludeComments, 325 &clangd::CodeCompleteOptions::IncludeCodePatterns, 326 &clangd::CodeCompleteOptions::IncludeIneligibleResults, 327 }; 328 // Test default options. 329 Test({}); 330 // Test with one flag flipped. 331 for (auto &F : Flags) { 332 clangd::CodeCompleteOptions O; 333 O.*F ^= true; 334 Test(O); 335 } 336 } 337 338 TEST(CompletionTest, Accessible) { 339 auto Internal = completions(R"cpp( 340 class Foo { 341 public: void pub(); 342 protected: void prot(); 343 private: void priv(); 344 }; 345 void Foo::pub() { this->^ } 346 )cpp"); 347 EXPECT_THAT(Internal.Completions, 348 AllOf(Has("priv"), Has("prot"), Has("pub"))); 349 350 auto External = completions(R"cpp( 351 class Foo { 352 public: void pub(); 353 protected: void prot(); 354 private: void priv(); 355 }; 356 void test() { 357 Foo F; 358 F.^ 359 } 360 )cpp"); 361 EXPECT_THAT(External.Completions, 362 AllOf(Has("pub"), Not(Has("prot")), Not(Has("priv")))); 363 } 364 365 TEST(CompletionTest, Qualifiers) { 366 auto Results = completions(R"cpp( 367 class Foo { 368 public: int foo() const; 369 int bar() const; 370 }; 371 class Bar : public Foo { 372 int foo() const; 373 }; 374 void test() { Bar().^ } 375 )cpp"); 376 EXPECT_THAT(Results.Completions, 377 Contains(AllOf(Qualifier(""), Named("bar")))); 378 // Hidden members are not shown. 379 EXPECT_THAT(Results.Completions, 380 Not(Contains(AllOf(Qualifier("Foo::"), Named("foo"))))); 381 // Private members are not shown. 382 EXPECT_THAT(Results.Completions, 383 Not(Contains(AllOf(Qualifier(""), Named("foo"))))); 384 } 385 386 TEST(CompletionTest, InjectedTypename) { 387 // These are suppressed when accessed as a member... 388 EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").Completions, 389 Not(Has("X"))); 390 EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").Completions, 391 Not(Has("X"))); 392 // ...but accessible in other, more useful cases. 393 EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").Completions, 394 Has("X")); 395 EXPECT_THAT( 396 completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions, 397 Has("Y")); 398 EXPECT_THAT( 399 completions( 400 "template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };") 401 .Completions, 402 Has("Y")); 403 // This case is marginal (`using X::X` is useful), we allow it for now. 404 EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").Completions, 405 Has("X")); 406 } 407 408 TEST(CompletionTest, SkipInjectedWhenUnqualified) { 409 EXPECT_THAT(completions("struct X { void f() { X^ }};").Completions, 410 ElementsAre(Named("X"), Named("~X"))); 411 } 412 413 TEST(CompletionTest, Snippets) { 414 clangd::CodeCompleteOptions Opts; 415 auto Results = completions( 416 R"cpp( 417 struct fake { 418 int a; 419 int f(int i, const float f) const; 420 }; 421 int main() { 422 fake f; 423 f.^ 424 } 425 )cpp", 426 /*IndexSymbols=*/{}, Opts); 427 EXPECT_THAT( 428 Results.Completions, 429 HasSubsequence(Named("a"), 430 SnippetSuffix("(${1:int i}, ${2:const float f})"))); 431 } 432 433 TEST(CompletionTest, NoSnippetsInUsings) { 434 clangd::CodeCompleteOptions Opts; 435 Opts.EnableSnippets = true; 436 auto Results = completions( 437 R"cpp( 438 namespace ns { 439 int func(int a, int b); 440 } 441 442 using ns::^; 443 )cpp", 444 /*IndexSymbols=*/{}, Opts); 445 EXPECT_THAT(Results.Completions, 446 ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"), 447 SnippetSuffix("")))); 448 449 // Check index completions too. 450 auto Func = func("ns::func"); 451 Func.CompletionSnippetSuffix = "(${1:int a}, ${2: int b})"; 452 Func.Signature = "(int a, int b)"; 453 Func.ReturnType = "void"; 454 455 Results = completions(R"cpp( 456 namespace ns {} 457 using ns::^; 458 )cpp", 459 /*IndexSymbols=*/{Func}, Opts); 460 EXPECT_THAT(Results.Completions, 461 ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"), 462 SnippetSuffix("")))); 463 464 // Check all-scopes completions too. 465 Opts.AllScopes = true; 466 Results = completions(R"cpp( 467 using ^; 468 )cpp", 469 /*IndexSymbols=*/{Func}, Opts); 470 EXPECT_THAT(Results.Completions, 471 Contains(AllOf(Named("func"), Labeled("ns::func(int a, int b)"), 472 SnippetSuffix("")))); 473 } 474 475 TEST(CompletionTest, Kinds) { 476 auto Results = completions( 477 R"cpp( 478 int variable; 479 struct Struct {}; 480 int function(); 481 // make sure MACRO is not included in preamble. 482 #define MACRO 10 483 int X = ^ 484 )cpp", 485 {func("indexFunction"), var("indexVariable"), cls("indexClass")}); 486 EXPECT_THAT(Results.Completions, 487 AllOf(Has("function", CompletionItemKind::Function), 488 Has("variable", CompletionItemKind::Variable), 489 Has("int", CompletionItemKind::Keyword), 490 Has("Struct", CompletionItemKind::Class), 491 Has("MACRO", CompletionItemKind::Text), 492 Has("indexFunction", CompletionItemKind::Function), 493 Has("indexVariable", CompletionItemKind::Variable), 494 Has("indexClass", CompletionItemKind::Class))); 495 496 Results = completions("nam^"); 497 EXPECT_THAT(Results.Completions, 498 Has("namespace", CompletionItemKind::Snippet)); 499 500 // Members of anonymous unions are of kind 'field'. 501 Results = completions( 502 R"cpp( 503 struct X{ 504 union { 505 void *a; 506 }; 507 }; 508 auto u = X().^ 509 )cpp"); 510 EXPECT_THAT( 511 Results.Completions, 512 UnorderedElementsAre(AllOf(Named("a"), Kind(CompletionItemKind::Field)))); 513 514 // Completion kinds for templates should not be unknown. 515 Results = completions( 516 R"cpp( 517 template <class T> struct complete_class {}; 518 template <class T> void complete_function(); 519 template <class T> using complete_type_alias = int; 520 template <class T> int complete_variable = 10; 521 522 struct X { 523 template <class T> static int complete_static_member = 10; 524 525 static auto x = complete_^ 526 } 527 )cpp"); 528 EXPECT_THAT( 529 Results.Completions, 530 UnorderedElementsAre( 531 AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)), 532 AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)), 533 AllOf(Named("complete_type_alias"), 534 Kind(CompletionItemKind::Interface)), 535 AllOf(Named("complete_variable"), Kind(CompletionItemKind::Variable)), 536 AllOf(Named("complete_static_member"), 537 Kind(CompletionItemKind::Property)))); 538 } 539 540 TEST(CompletionTest, NoDuplicates) { 541 auto Results = completions( 542 R"cpp( 543 class Adapter { 544 }; 545 546 void f() { 547 Adapter^ 548 } 549 )cpp", 550 {cls("Adapter")}); 551 552 // Make sure there are no duplicate entries of 'Adapter'. 553 EXPECT_THAT(Results.Completions, ElementsAre(Named("Adapter"))); 554 } 555 556 TEST(CompletionTest, ScopedNoIndex) { 557 auto Results = completions( 558 R"cpp( 559 namespace fake { int BigBang, Babble, Box; }; 560 int main() { fake::ba^ } 561 ")cpp"); 562 // Babble is a better match than BigBang. Box doesn't match at all. 563 EXPECT_THAT(Results.Completions, 564 ElementsAre(Named("Babble"), Named("BigBang"))); 565 } 566 567 TEST(CompletionTest, Scoped) { 568 auto Results = completions( 569 R"cpp( 570 namespace fake { int Babble, Box; }; 571 int main() { fake::ba^ } 572 ")cpp", 573 {var("fake::BigBang")}); 574 EXPECT_THAT(Results.Completions, 575 ElementsAre(Named("Babble"), Named("BigBang"))); 576 } 577 578 TEST(CompletionTest, ScopedWithFilter) { 579 auto Results = completions( 580 R"cpp( 581 void f() { ns::x^ } 582 )cpp", 583 {cls("ns::XYZ"), func("ns::foo")}); 584 EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ"))); 585 } 586 587 TEST(CompletionTest, ReferencesAffectRanking) { 588 auto Results = completions("int main() { abs^ }", {ns("absl"), func("absb")}); 589 EXPECT_THAT(Results.Completions, 590 HasSubsequence(Named("absb"), Named("absl"))); 591 Results = completions("int main() { abs^ }", 592 {withReferences(10000, ns("absl")), func("absb")}); 593 EXPECT_THAT(Results.Completions, 594 HasSubsequence(Named("absl"), Named("absb"))); 595 } 596 597 TEST(CompletionTest, ContextWords) { 598 auto Results = completions(R"cpp( 599 enum class Color { RED, YELLOW, BLUE }; 600 601 // (blank lines so the definition above isn't "context") 602 603 // "It was a yellow car," he said. "Big yellow car, new." 604 auto Finish = Color::^ 605 )cpp"); 606 // Yellow would normally sort last (alphabetic). 607 // But the recent mention shuold bump it up. 608 ASSERT_THAT(Results.Completions, 609 HasSubsequence(Named("YELLOW"), Named("BLUE"))); 610 } 611 612 TEST(CompletionTest, GlobalQualified) { 613 auto Results = completions( 614 R"cpp( 615 void f() { ::^ } 616 )cpp", 617 {cls("XYZ")}); 618 EXPECT_THAT(Results.Completions, 619 AllOf(Has("XYZ", CompletionItemKind::Class), 620 Has("f", CompletionItemKind::Function))); 621 } 622 623 TEST(CompletionTest, FullyQualified) { 624 auto Results = completions( 625 R"cpp( 626 namespace ns { void bar(); } 627 void f() { ::ns::^ } 628 )cpp", 629 {cls("ns::XYZ")}); 630 EXPECT_THAT(Results.Completions, 631 AllOf(Has("XYZ", CompletionItemKind::Class), 632 Has("bar", CompletionItemKind::Function))); 633 } 634 635 TEST(CompletionTest, SemaIndexMerge) { 636 auto Results = completions( 637 R"cpp( 638 namespace ns { int local; void both(); } 639 void f() { ::ns::^ } 640 )cpp", 641 {func("ns::both"), cls("ns::Index")}); 642 // We get results from both index and sema, with no duplicates. 643 EXPECT_THAT(Results.Completions, 644 UnorderedElementsAre( 645 AllOf(Named("local"), Origin(SymbolOrigin::AST)), 646 AllOf(Named("Index"), Origin(SymbolOrigin::Static)), 647 AllOf(Named("both"), 648 Origin(SymbolOrigin::AST | SymbolOrigin::Static)))); 649 } 650 651 TEST(CompletionTest, SemaIndexMergeWithLimit) { 652 clangd::CodeCompleteOptions Opts; 653 Opts.Limit = 1; 654 auto Results = completions( 655 R"cpp( 656 namespace ns { int local; void both(); } 657 void f() { ::ns::^ } 658 )cpp", 659 {func("ns::both"), cls("ns::Index")}, Opts); 660 EXPECT_EQ(Results.Completions.size(), Opts.Limit); 661 EXPECT_TRUE(Results.HasMore); 662 } 663 664 TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) { 665 MockFSProvider FS; 666 MockCompilationDatabase CDB; 667 std::string Subdir = testPath("sub"); 668 std::string SearchDirArg = (Twine("-I") + Subdir).str(); 669 CDB.ExtraClangFlags = {SearchDirArg.c_str()}; 670 std::string BarHeader = testPath("sub/bar.h"); 671 FS.Files[BarHeader] = ""; 672 673 IgnoreDiagnostics DiagConsumer; 674 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 675 auto BarURI = URI::create(BarHeader).toString(); 676 Symbol Sym = cls("ns::X"); 677 Sym.CanonicalDeclaration.FileURI = BarURI.c_str(); 678 Sym.IncludeHeaders.emplace_back(BarURI, 1); 679 // Shoten include path based on search dirctory and insert. 680 auto Results = completions(Server, 681 R"cpp( 682 int main() { ns::^ } 683 )cpp", 684 {Sym}); 685 EXPECT_THAT(Results.Completions, 686 ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\"")))); 687 // Can be disabled via option. 688 CodeCompleteOptions NoInsertion; 689 NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert; 690 Results = completions(Server, 691 R"cpp( 692 int main() { ns::^ } 693 )cpp", 694 {Sym}, NoInsertion); 695 EXPECT_THAT(Results.Completions, 696 ElementsAre(AllOf(Named("X"), Not(InsertInclude())))); 697 // Duplicate based on inclusions in preamble. 698 Results = completions(Server, 699 R"cpp( 700 #include "sub/bar.h" // not shortest, so should only match resolved. 701 int main() { ns::^ } 702 )cpp", 703 {Sym}); 704 EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"), 705 Not(InsertInclude())))); 706 } 707 708 TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) { 709 MockFSProvider FS; 710 MockCompilationDatabase CDB; 711 712 IgnoreDiagnostics DiagConsumer; 713 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 714 Symbol SymX = cls("ns::X"); 715 Symbol SymY = cls("ns::Y"); 716 std::string BarHeader = testPath("bar.h"); 717 auto BarURI = URI::create(BarHeader).toString(); 718 SymX.CanonicalDeclaration.FileURI = BarURI.c_str(); 719 SymY.CanonicalDeclaration.FileURI = BarURI.c_str(); 720 SymX.IncludeHeaders.emplace_back("<bar>", 1); 721 SymY.IncludeHeaders.emplace_back("<bar>", 1); 722 // Shoten include path based on search dirctory and insert. 723 auto Results = completions(Server, 724 R"cpp( 725 namespace ns { 726 class X; 727 class Y {}; 728 } 729 int main() { ns::^ } 730 )cpp", 731 {SymX, SymY}); 732 EXPECT_THAT(Results.Completions, 733 ElementsAre(AllOf(Named("X"), Not(InsertInclude())), 734 AllOf(Named("Y"), Not(InsertInclude())))); 735 } 736 737 TEST(CompletionTest, IndexSuppressesPreambleCompletions) { 738 MockFSProvider FS; 739 MockCompilationDatabase CDB; 740 IgnoreDiagnostics DiagConsumer; 741 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 742 743 FS.Files[testPath("bar.h")] = 744 R"cpp(namespace ns { struct preamble { int member; }; })cpp"; 745 auto File = testPath("foo.cpp"); 746 Annotations Test(R"cpp( 747 #include "bar.h" 748 namespace ns { int local; } 749 void f() { ns::^; } 750 void f2() { ns::preamble().$2^; } 751 )cpp"); 752 runAddDocument(Server, File, Test.code()); 753 clangd::CodeCompleteOptions Opts = {}; 754 755 auto I = memIndex({var("ns::index")}); 756 Opts.Index = I.get(); 757 auto WithIndex = cantFail(runCodeComplete(Server, File, Test.point(), Opts)); 758 EXPECT_THAT(WithIndex.Completions, 759 UnorderedElementsAre(Named("local"), Named("index"))); 760 auto ClassFromPreamble = 761 cantFail(runCodeComplete(Server, File, Test.point("2"), Opts)); 762 EXPECT_THAT(ClassFromPreamble.Completions, Contains(Named("member"))); 763 764 Opts.Index = nullptr; 765 auto WithoutIndex = 766 cantFail(runCodeComplete(Server, File, Test.point(), Opts)); 767 EXPECT_THAT(WithoutIndex.Completions, 768 UnorderedElementsAre(Named("local"), Named("preamble"))); 769 } 770 771 // This verifies that we get normal preprocessor completions in the preamble. 772 // This is a regression test for an old bug: if we override the preamble and 773 // try to complete inside it, clang kicks our completion point just outside the 774 // preamble, resulting in always getting top-level completions. 775 TEST(CompletionTest, CompletionInPreamble) { 776 auto Results = completions(R"cpp( 777 #ifnd^ef FOO_H_ 778 #define BAR_H_ 779 #include <bar.h> 780 int foo() {} 781 #endif 782 )cpp") 783 .Completions; 784 EXPECT_THAT(Results, ElementsAre(Named("ifndef"))); 785 } 786 787 TEST(CompletionTest, DynamicIndexIncludeInsertion) { 788 MockFSProvider FS; 789 MockCompilationDatabase CDB; 790 IgnoreDiagnostics DiagConsumer; 791 ClangdServer::Options Opts = ClangdServer::optsForTest(); 792 Opts.BuildDynamicSymbolIndex = true; 793 ClangdServer Server(CDB, FS, DiagConsumer, Opts); 794 795 FS.Files[testPath("foo_header.h")] = R"cpp( 796 #pragma once 797 struct Foo { 798 // Member doc 799 int foo(); 800 }; 801 )cpp"; 802 const std::string FileContent(R"cpp( 803 #include "foo_header.h" 804 int Foo::foo() { 805 return 42; 806 } 807 )cpp"); 808 Server.addDocument(testPath("foo_impl.cpp"), FileContent); 809 // Wait for the dynamic index being built. 810 ASSERT_TRUE(Server.blockUntilIdleForTest()); 811 EXPECT_THAT(completions(Server, "Foo^ foo;").Completions, 812 ElementsAre(AllOf(Named("Foo"), HasInclude("\"foo_header.h\""), 813 InsertInclude()))); 814 } 815 816 TEST(CompletionTest, DynamicIndexMultiFile) { 817 MockFSProvider FS; 818 MockCompilationDatabase CDB; 819 IgnoreDiagnostics DiagConsumer; 820 auto Opts = ClangdServer::optsForTest(); 821 Opts.BuildDynamicSymbolIndex = true; 822 ClangdServer Server(CDB, FS, DiagConsumer, Opts); 823 824 FS.Files[testPath("foo.h")] = R"cpp( 825 namespace ns { class XYZ {}; void foo(int x) {} } 826 )cpp"; 827 runAddDocument(Server, testPath("foo.cpp"), R"cpp( 828 #include "foo.h" 829 )cpp"); 830 831 auto File = testPath("bar.cpp"); 832 Annotations Test(R"cpp( 833 namespace ns { 834 class XXX {}; 835 /// Doooc 836 void fooooo() {} 837 } 838 void f() { ns::^ } 839 )cpp"); 840 runAddDocument(Server, File, Test.code()); 841 842 auto Results = cantFail(runCodeComplete(Server, File, Test.point(), {})); 843 // "XYZ" and "foo" are not included in the file being completed but are still 844 // visible through the index. 845 EXPECT_THAT(Results.Completions, Has("XYZ", CompletionItemKind::Class)); 846 EXPECT_THAT(Results.Completions, Has("foo", CompletionItemKind::Function)); 847 EXPECT_THAT(Results.Completions, Has("XXX", CompletionItemKind::Class)); 848 EXPECT_THAT(Results.Completions, 849 Contains((Named("fooooo"), Kind(CompletionItemKind::Function), 850 Doc("Doooc"), ReturnType("void")))); 851 } 852 853 TEST(CompletionTest, Documentation) { 854 auto Results = completions( 855 R"cpp( 856 // Non-doxygen comment. 857 int foo(); 858 /// Doxygen comment. 859 /// \param int a 860 int bar(int a); 861 /* Multi-line 862 block comment 863 */ 864 int baz(); 865 866 int x = ^ 867 )cpp"); 868 EXPECT_THAT(Results.Completions, 869 Contains(AllOf(Named("foo"), Doc("Non-doxygen comment.")))); 870 EXPECT_THAT( 871 Results.Completions, 872 Contains(AllOf(Named("bar"), Doc("Doxygen comment.\n\\param int a")))); 873 EXPECT_THAT(Results.Completions, 874 Contains(AllOf(Named("baz"), Doc("Multi-line\nblock comment")))); 875 } 876 877 TEST(CompletionTest, CommentsFromSystemHeaders) { 878 MockFSProvider FS; 879 MockCompilationDatabase CDB; 880 IgnoreDiagnostics DiagConsumer; 881 882 auto Opts = ClangdServer::optsForTest(); 883 Opts.BuildDynamicSymbolIndex = true; 884 885 ClangdServer Server(CDB, FS, DiagConsumer, Opts); 886 887 FS.Files[testPath("foo.h")] = R"cpp( 888 #pragma GCC system_header 889 890 // This comment should be retained! 891 int foo(); 892 )cpp"; 893 894 auto Results = completions(Server, 895 R"cpp( 896 #include "foo.h" 897 int x = foo^ 898 )cpp"); 899 EXPECT_THAT( 900 Results.Completions, 901 Contains(AllOf(Named("foo"), Doc("This comment should be retained!")))); 902 } 903 904 TEST(CompletionTest, GlobalCompletionFiltering) { 905 906 Symbol Class = cls("XYZ"); 907 Class.Flags = static_cast<Symbol::SymbolFlag>( 908 Class.Flags & ~(Symbol::IndexedForCodeCompletion)); 909 Symbol Func = func("XYZ::foooo"); 910 Func.Flags = static_cast<Symbol::SymbolFlag>( 911 Func.Flags & ~(Symbol::IndexedForCodeCompletion)); 912 913 auto Results = completions(R"(// void f() { 914 XYZ::foooo^ 915 })", 916 {Class, Func}); 917 EXPECT_THAT(Results.Completions, IsEmpty()); 918 } 919 920 TEST(CodeCompleteTest, DisableTypoCorrection) { 921 auto Results = completions(R"cpp( 922 namespace clang { int v; } 923 void f() { clangd::^ 924 )cpp"); 925 EXPECT_TRUE(Results.Completions.empty()); 926 } 927 928 TEST(CodeCompleteTest, NoColonColonAtTheEnd) { 929 auto Results = completions(R"cpp( 930 namespace clang { } 931 void f() { 932 clan^ 933 } 934 )cpp"); 935 936 EXPECT_THAT(Results.Completions, Contains(Labeled("clang"))); 937 EXPECT_THAT(Results.Completions, Not(Contains(Labeled("clang::")))); 938 } 939 940 TEST(CompletionTest, BacktrackCrashes) { 941 // Sema calls code completion callbacks twice in these cases. 942 auto Results = completions(R"cpp( 943 namespace ns { 944 struct FooBarBaz {}; 945 } // namespace ns 946 947 int foo(ns::FooBar^ 948 )cpp"); 949 950 EXPECT_THAT(Results.Completions, ElementsAre(Labeled("FooBarBaz"))); 951 952 // Check we don't crash in that case too. 953 completions(R"cpp( 954 struct FooBarBaz {}; 955 void test() { 956 if (FooBarBaz * x^) {} 957 } 958 )cpp"); 959 } 960 961 TEST(CompletionTest, CompleteInMacroWithStringification) { 962 auto Results = completions(R"cpp( 963 void f(const char *, int x); 964 #define F(x) f(#x, x) 965 966 namespace ns { 967 int X; 968 int Y; 969 } // namespace ns 970 971 int f(int input_num) { 972 F(ns::^) 973 } 974 )cpp"); 975 976 EXPECT_THAT(Results.Completions, 977 UnorderedElementsAre(Named("X"), Named("Y"))); 978 } 979 980 TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) { 981 auto Results = completions(R"cpp( 982 void f(const char *, int x); 983 #define F(x) f(#x, x) 984 985 namespace ns { 986 int X; 987 988 int f(int input_num) { 989 F(^) 990 } 991 } // namespace ns 992 )cpp"); 993 994 EXPECT_THAT(Results.Completions, Contains(Named("X"))); 995 } 996 997 TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) { 998 auto Results = completions(R"cpp( 999 int bar(int param_in_bar) { 1000 } 1001 1002 int foo(int param_in_foo) { 1003 #if 0 1004 // In recorvery mode, "param_in_foo" will also be suggested among many other 1005 // unrelated symbols; however, this is really a special case where this works. 1006 // If the #if block is outside of the function, "param_in_foo" is still 1007 // suggested, but "bar" and "foo" are missing. So the recovery mode doesn't 1008 // really provide useful results in excluded branches. 1009 par^ 1010 #endif 1011 } 1012 )cpp"); 1013 1014 EXPECT_TRUE(Results.Completions.empty()); 1015 } 1016 1017 TEST(CompletionTest, DefaultArgs) { 1018 clangd::CodeCompleteOptions Opts; 1019 std::string Context = R"cpp( 1020 int X(int A = 0); 1021 int Y(int A, int B = 0); 1022 int Z(int A, int B = 0, int C = 0, int D = 0); 1023 )cpp"; 1024 EXPECT_THAT(completions(Context + "int y = X^", {}, Opts).Completions, 1025 UnorderedElementsAre(Labeled("X(int A = 0)"))); 1026 EXPECT_THAT(completions(Context + "int y = Y^", {}, Opts).Completions, 1027 UnorderedElementsAre(AllOf(Labeled("Y(int A, int B = 0)"), 1028 SnippetSuffix("(${1:int A})")))); 1029 EXPECT_THAT(completions(Context + "int y = Z^", {}, Opts).Completions, 1030 UnorderedElementsAre( 1031 AllOf(Labeled("Z(int A, int B = 0, int C = 0, int D = 0)"), 1032 SnippetSuffix("(${1:int A})")))); 1033 } 1034 1035 TEST(CompletionTest, NoCrashWithTemplateParamsAndPreferredTypes) { 1036 auto Completions = completions(R"cpp( 1037 template <template <class> class TT> int foo() { 1038 int a = ^ 1039 } 1040 )cpp") 1041 .Completions; 1042 EXPECT_THAT(Completions, Contains(Named("TT"))); 1043 } 1044 1045 SignatureHelp signatures(llvm::StringRef Text, Position Point, 1046 std::vector<Symbol> IndexSymbols = {}) { 1047 std::unique_ptr<SymbolIndex> Index; 1048 if (!IndexSymbols.empty()) 1049 Index = memIndex(IndexSymbols); 1050 1051 MockFSProvider FS; 1052 MockCompilationDatabase CDB; 1053 IgnoreDiagnostics DiagConsumer; 1054 ClangdServer::Options Opts = ClangdServer::optsForTest(); 1055 Opts.StaticIndex = Index.get(); 1056 1057 ClangdServer Server(CDB, FS, DiagConsumer, Opts); 1058 auto File = testPath("foo.cpp"); 1059 runAddDocument(Server, File, Text); 1060 return llvm::cantFail(runSignatureHelp(Server, File, Point)); 1061 } 1062 1063 SignatureHelp signatures(llvm::StringRef Text, 1064 std::vector<Symbol> IndexSymbols = {}) { 1065 Annotations Test(Text); 1066 return signatures(Test.code(), Test.point(), std::move(IndexSymbols)); 1067 } 1068 1069 struct ExpectedParameter { 1070 std::string Text; 1071 std::pair<unsigned, unsigned> Offsets; 1072 }; 1073 MATCHER_P(ParamsAre, P, "") { 1074 if (P.size() != arg.parameters.size()) 1075 return false; 1076 for (unsigned I = 0; I < P.size(); ++I) { 1077 if (P[I].Text != arg.parameters[I].labelString || 1078 P[I].Offsets != arg.parameters[I].labelOffsets) 1079 return false; 1080 } 1081 return true; 1082 } 1083 MATCHER_P(SigDoc, Doc, "") { return arg.documentation == Doc; } 1084 1085 /// \p AnnotatedLabel is a signature label with ranges marking parameters, e.g. 1086 /// foo([[int p1]], [[double p2]]) -> void 1087 Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) { 1088 llvm::Annotations A(AnnotatedLabel); 1089 std::string Label = A.code(); 1090 std::vector<ExpectedParameter> Parameters; 1091 for (auto Range : A.ranges()) { 1092 Parameters.emplace_back(); 1093 1094 ExpectedParameter &P = Parameters.back(); 1095 P.Text = Label.substr(Range.Begin, Range.End - Range.Begin); 1096 P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin)); 1097 P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End)); 1098 } 1099 return AllOf(SigHelpLabeled(Label), ParamsAre(Parameters)); 1100 } 1101 1102 TEST(SignatureHelpTest, Overloads) { 1103 auto Results = signatures(R"cpp( 1104 void foo(int x, int y); 1105 void foo(int x, float y); 1106 void foo(float x, int y); 1107 void foo(float x, float y); 1108 void bar(int x, int y = 0); 1109 int main() { foo(^); } 1110 )cpp"); 1111 EXPECT_THAT(Results.signatures, 1112 UnorderedElementsAre(Sig("foo([[float x]], [[float y]]) -> void"), 1113 Sig("foo([[float x]], [[int y]]) -> void"), 1114 Sig("foo([[int x]], [[float y]]) -> void"), 1115 Sig("foo([[int x]], [[int y]]) -> void"))); 1116 // We always prefer the first signature. 1117 EXPECT_EQ(0, Results.activeSignature); 1118 EXPECT_EQ(0, Results.activeParameter); 1119 } 1120 1121 TEST(SignatureHelpTest, DefaultArgs) { 1122 auto Results = signatures(R"cpp( 1123 void bar(int x, int y = 0); 1124 void bar(float x = 0, int y = 42); 1125 int main() { bar(^ 1126 )cpp"); 1127 EXPECT_THAT(Results.signatures, 1128 UnorderedElementsAre( 1129 Sig("bar([[int x]], [[int y = 0]]) -> void"), 1130 Sig("bar([[float x = 0]], [[int y = 42]]) -> void"))); 1131 EXPECT_EQ(0, Results.activeSignature); 1132 EXPECT_EQ(0, Results.activeParameter); 1133 } 1134 1135 TEST(SignatureHelpTest, ActiveArg) { 1136 auto Results = signatures(R"cpp( 1137 int baz(int a, int b, int c); 1138 int main() { baz(baz(1,2,3), ^); } 1139 )cpp"); 1140 EXPECT_THAT(Results.signatures, 1141 ElementsAre(Sig("baz([[int a]], [[int b]], [[int c]]) -> int"))); 1142 EXPECT_EQ(0, Results.activeSignature); 1143 EXPECT_EQ(1, Results.activeParameter); 1144 } 1145 1146 TEST(SignatureHelpTest, OpeningParen) { 1147 llvm::StringLiteral Tests[] = {// Recursive function call. 1148 R"cpp( 1149 int foo(int a, int b, int c); 1150 int main() { 1151 foo(foo $p^( foo(10, 10, 10), ^ ))); 1152 })cpp", 1153 // Functional type cast. 1154 R"cpp( 1155 struct Foo { 1156 Foo(int a, int b, int c); 1157 }; 1158 int main() { 1159 Foo $p^( 10, ^ ); 1160 })cpp", 1161 // New expression. 1162 R"cpp( 1163 struct Foo { 1164 Foo(int a, int b, int c); 1165 }; 1166 int main() { 1167 new Foo $p^( 10, ^ ); 1168 })cpp", 1169 // Macro expansion. 1170 R"cpp( 1171 int foo(int a, int b, int c); 1172 #define FOO foo( 1173 1174 int main() { 1175 // Macro expansions. 1176 $p^FOO 10, ^ ); 1177 })cpp", 1178 // Macro arguments. 1179 R"cpp( 1180 int foo(int a, int b, int c); 1181 int main() { 1182 #define ID(X) X 1183 ID(foo $p^( foo(10), ^ )) 1184 })cpp"}; 1185 1186 for (auto Test : Tests) { 1187 Annotations Code(Test); 1188 EXPECT_EQ(signatures(Code.code(), Code.point()).argListStart, 1189 Code.point("p")) 1190 << "Test source:" << Test; 1191 } 1192 } 1193 1194 class IndexRequestCollector : public SymbolIndex { 1195 public: 1196 bool 1197 fuzzyFind(const FuzzyFindRequest &Req, 1198 llvm::function_ref<void(const Symbol &)> Callback) const override { 1199 std::unique_lock<std::mutex> Lock(Mut); 1200 Requests.push_back(Req); 1201 ReceivedRequestCV.notify_one(); 1202 return true; 1203 } 1204 1205 void lookup(const LookupRequest &, 1206 llvm::function_ref<void(const Symbol &)>) const override {} 1207 1208 bool refs(const RefsRequest &, 1209 llvm::function_ref<void(const Ref &)>) const override { 1210 return false; 1211 } 1212 1213 void relations(const RelationsRequest &, 1214 llvm::function_ref<void(const SymbolID &, const Symbol &)>) 1215 const override {} 1216 1217 // This is incorrect, but IndexRequestCollector is not an actual index and it 1218 // isn't used in production code. 1219 size_t estimateMemoryUsage() const override { return 0; } 1220 1221 const std::vector<FuzzyFindRequest> consumeRequests(size_t Num) const { 1222 std::unique_lock<std::mutex> Lock(Mut); 1223 EXPECT_TRUE(wait(Lock, ReceivedRequestCV, timeoutSeconds(30), 1224 [this, Num] { return Requests.size() == Num; })); 1225 auto Reqs = std::move(Requests); 1226 Requests = {}; 1227 return Reqs; 1228 } 1229 1230 private: 1231 // We need a mutex to handle async fuzzy find requests. 1232 mutable std::condition_variable ReceivedRequestCV; 1233 mutable std::mutex Mut; 1234 mutable std::vector<FuzzyFindRequest> Requests; 1235 }; 1236 1237 // Clients have to consume exactly Num requests. 1238 std::vector<FuzzyFindRequest> captureIndexRequests(llvm::StringRef Code, 1239 size_t Num = 1) { 1240 clangd::CodeCompleteOptions Opts; 1241 IndexRequestCollector Requests; 1242 Opts.Index = &Requests; 1243 completions(Code, {}, Opts); 1244 const auto Reqs = Requests.consumeRequests(Num); 1245 EXPECT_EQ(Reqs.size(), Num); 1246 return Reqs; 1247 } 1248 1249 TEST(CompletionTest, UnqualifiedIdQuery) { 1250 auto Requests = captureIndexRequests(R"cpp( 1251 namespace std {} 1252 using namespace std; 1253 namespace ns { 1254 void f() { 1255 vec^ 1256 } 1257 } 1258 )cpp"); 1259 1260 EXPECT_THAT(Requests, 1261 ElementsAre(Field(&FuzzyFindRequest::Scopes, 1262 UnorderedElementsAre("", "ns::", "std::")))); 1263 } 1264 1265 TEST(CompletionTest, EnclosingScopeComesFirst) { 1266 auto Requests = captureIndexRequests(R"cpp( 1267 namespace std {} 1268 using namespace std; 1269 namespace nx { 1270 namespace ns { 1271 namespace { 1272 void f() { 1273 vec^ 1274 } 1275 } 1276 } 1277 } 1278 )cpp"); 1279 1280 EXPECT_THAT(Requests, 1281 ElementsAre(Field( 1282 &FuzzyFindRequest::Scopes, 1283 UnorderedElementsAre("", "std::", "nx::ns::", "nx::")))); 1284 EXPECT_EQ(Requests[0].Scopes[0], "nx::ns::"); 1285 } 1286 1287 TEST(CompletionTest, ResolvedQualifiedIdQuery) { 1288 auto Requests = captureIndexRequests(R"cpp( 1289 namespace ns1 {} 1290 namespace ns2 {} // ignore 1291 namespace ns3 { namespace nns3 {} } 1292 namespace foo { 1293 using namespace ns1; 1294 using namespace ns3::nns3; 1295 } 1296 namespace ns { 1297 void f() { 1298 foo::^ 1299 } 1300 } 1301 )cpp"); 1302 1303 EXPECT_THAT(Requests, 1304 ElementsAre(Field( 1305 &FuzzyFindRequest::Scopes, 1306 UnorderedElementsAre("foo::", "ns1::", "ns3::nns3::")))); 1307 } 1308 1309 TEST(CompletionTest, UnresolvedQualifierIdQuery) { 1310 auto Requests = captureIndexRequests(R"cpp( 1311 namespace a {} 1312 using namespace a; 1313 namespace ns { 1314 void f() { 1315 bar::^ 1316 } 1317 } // namespace ns 1318 )cpp"); 1319 1320 EXPECT_THAT(Requests, 1321 ElementsAre(Field( 1322 &FuzzyFindRequest::Scopes, 1323 UnorderedElementsAre("a::bar::", "ns::bar::", "bar::")))); 1324 } 1325 1326 TEST(CompletionTest, UnresolvedNestedQualifierIdQuery) { 1327 auto Requests = captureIndexRequests(R"cpp( 1328 namespace a {} 1329 using namespace a; 1330 namespace ns { 1331 void f() { 1332 ::a::bar::^ 1333 } 1334 } // namespace ns 1335 )cpp"); 1336 1337 EXPECT_THAT(Requests, ElementsAre(Field(&FuzzyFindRequest::Scopes, 1338 UnorderedElementsAre("a::bar::")))); 1339 } 1340 1341 TEST(CompletionTest, EmptyQualifiedQuery) { 1342 auto Requests = captureIndexRequests(R"cpp( 1343 namespace ns { 1344 void f() { 1345 ^ 1346 } 1347 } // namespace ns 1348 )cpp"); 1349 1350 EXPECT_THAT(Requests, ElementsAre(Field(&FuzzyFindRequest::Scopes, 1351 UnorderedElementsAre("", "ns::")))); 1352 } 1353 1354 TEST(CompletionTest, GlobalQualifiedQuery) { 1355 auto Requests = captureIndexRequests(R"cpp( 1356 namespace ns { 1357 void f() { 1358 ::^ 1359 } 1360 } // namespace ns 1361 )cpp"); 1362 1363 EXPECT_THAT(Requests, ElementsAre(Field(&FuzzyFindRequest::Scopes, 1364 UnorderedElementsAre("")))); 1365 } 1366 1367 TEST(CompletionTest, NoDuplicatedQueryScopes) { 1368 auto Requests = captureIndexRequests(R"cpp( 1369 namespace {} 1370 1371 namespace na { 1372 namespace {} 1373 namespace nb { 1374 ^ 1375 } // namespace nb 1376 } // namespace na 1377 )cpp"); 1378 1379 EXPECT_THAT(Requests, 1380 ElementsAre(Field(&FuzzyFindRequest::Scopes, 1381 UnorderedElementsAre("na::", "na::nb::", "")))); 1382 } 1383 1384 TEST(CompletionTest, NoIndexCompletionsInsideClasses) { 1385 auto Completions = completions( 1386 R"cpp( 1387 struct Foo { 1388 int SomeNameOfField; 1389 typedef int SomeNameOfTypedefField; 1390 }; 1391 1392 Foo::^)cpp", 1393 {func("::SomeNameInTheIndex"), func("::Foo::SomeNameInTheIndex")}); 1394 1395 EXPECT_THAT(Completions.Completions, 1396 AllOf(Contains(Labeled("SomeNameOfField")), 1397 Contains(Labeled("SomeNameOfTypedefField")), 1398 Not(Contains(Labeled("SomeNameInTheIndex"))))); 1399 } 1400 1401 TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) { 1402 { 1403 auto Completions = completions( 1404 R"cpp( 1405 template <class T> 1406 void foo() { 1407 T::^ 1408 } 1409 )cpp", 1410 {func("::SomeNameInTheIndex")}); 1411 1412 EXPECT_THAT(Completions.Completions, 1413 Not(Contains(Labeled("SomeNameInTheIndex")))); 1414 } 1415 1416 { 1417 auto Completions = completions( 1418 R"cpp( 1419 template <class T> 1420 void foo() { 1421 T::template Y<int>::^ 1422 } 1423 )cpp", 1424 {func("::SomeNameInTheIndex")}); 1425 1426 EXPECT_THAT(Completions.Completions, 1427 Not(Contains(Labeled("SomeNameInTheIndex")))); 1428 } 1429 1430 { 1431 auto Completions = completions( 1432 R"cpp( 1433 template <class T> 1434 void foo() { 1435 T::foo::^ 1436 } 1437 )cpp", 1438 {func("::SomeNameInTheIndex")}); 1439 1440 EXPECT_THAT(Completions.Completions, 1441 Not(Contains(Labeled("SomeNameInTheIndex")))); 1442 } 1443 } 1444 1445 TEST(CompletionTest, OverloadBundling) { 1446 clangd::CodeCompleteOptions Opts; 1447 Opts.BundleOverloads = true; 1448 1449 std::string Context = R"cpp( 1450 struct X { 1451 // Overload with int 1452 int a(int); 1453 // Overload with bool 1454 int a(bool); 1455 int b(float); 1456 }; 1457 int GFuncC(int); 1458 int GFuncD(int); 1459 )cpp"; 1460 1461 // Member completions are bundled. 1462 EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).Completions, 1463 UnorderedElementsAre(Labeled("a(…)"), Labeled("b(float)"))); 1464 1465 // Non-member completions are bundled, including index+sema. 1466 Symbol NoArgsGFunc = func("GFuncC"); 1467 EXPECT_THAT( 1468 completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions, 1469 UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)"))); 1470 1471 // Differences in header-to-insert suppress bundling. 1472 std::string DeclFile = URI::create(testPath("foo")).toString(); 1473 NoArgsGFunc.CanonicalDeclaration.FileURI = DeclFile.c_str(); 1474 NoArgsGFunc.IncludeHeaders.emplace_back("<foo>", 1); 1475 EXPECT_THAT( 1476 completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions, 1477 UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")), 1478 Labeled("GFuncC(int)"), Labeled("GFuncD(int)"))); 1479 1480 // Examine a bundled completion in detail. 1481 auto A = 1482 completions(Context + "int y = X().a^", {}, Opts).Completions.front(); 1483 EXPECT_EQ(A.Name, "a"); 1484 EXPECT_EQ(A.Signature, "(…)"); 1485 EXPECT_EQ(A.BundleSize, 2u); 1486 EXPECT_EQ(A.Kind, CompletionItemKind::Method); 1487 EXPECT_EQ(A.ReturnType, "int"); // All overloads return int. 1488 // For now we just return one of the doc strings arbitrarily. 1489 EXPECT_THAT(A.Documentation, AnyOf(HasSubstr("Overload with int"), 1490 HasSubstr("Overload with bool"))); 1491 EXPECT_EQ(A.SnippetSuffix, "($0)"); 1492 } 1493 1494 TEST(CompletionTest, DocumentationFromChangedFileCrash) { 1495 MockFSProvider FS; 1496 auto FooH = testPath("foo.h"); 1497 auto FooCpp = testPath("foo.cpp"); 1498 FS.Files[FooH] = R"cpp( 1499 // this is my documentation comment. 1500 int func(); 1501 )cpp"; 1502 FS.Files[FooCpp] = ""; 1503 1504 MockCompilationDatabase CDB; 1505 IgnoreDiagnostics DiagConsumer; 1506 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1507 1508 Annotations Source(R"cpp( 1509 #include "foo.h" 1510 int func() { 1511 // This makes sure we have func from header in the AST. 1512 } 1513 int a = fun^ 1514 )cpp"); 1515 Server.addDocument(FooCpp, Source.code(), WantDiagnostics::Yes); 1516 // We need to wait for preamble to build. 1517 ASSERT_TRUE(Server.blockUntilIdleForTest()); 1518 1519 // Change the header file. Completion will reuse the old preamble! 1520 FS.Files[FooH] = R"cpp( 1521 int func(); 1522 )cpp"; 1523 1524 clangd::CodeCompleteOptions Opts; 1525 Opts.IncludeComments = true; 1526 CodeCompleteResult Completions = 1527 cantFail(runCodeComplete(Server, FooCpp, Source.point(), Opts)); 1528 // We shouldn't crash. Unfortunately, current workaround is to not produce 1529 // comments for symbols from headers. 1530 EXPECT_THAT(Completions.Completions, 1531 Contains(AllOf(Not(IsDocumented()), Named("func")))); 1532 } 1533 1534 TEST(CompletionTest, NonDocComments) { 1535 MockFSProvider FS; 1536 auto FooCpp = testPath("foo.cpp"); 1537 FS.Files[FooCpp] = ""; 1538 1539 MockCompilationDatabase CDB; 1540 IgnoreDiagnostics DiagConsumer; 1541 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1542 1543 Annotations Source(R"cpp( 1544 // We ignore namespace comments, for rationale see CodeCompletionStrings.h. 1545 namespace comments_ns { 1546 } 1547 1548 // ------------------ 1549 int comments_foo(); 1550 1551 // A comment and a decl are separated by newlines. 1552 // Therefore, the comment shouldn't show up as doc comment. 1553 1554 int comments_bar(); 1555 1556 // this comment should be in the results. 1557 int comments_baz(); 1558 1559 1560 template <class T> 1561 struct Struct { 1562 int comments_qux(); 1563 int comments_quux(); 1564 }; 1565 1566 1567 // This comment should not be there. 1568 1569 template <class T> 1570 int Struct<T>::comments_qux() { 1571 } 1572 1573 // This comment **should** be in results. 1574 template <class T> 1575 int Struct<T>::comments_quux() { 1576 int a = comments^; 1577 } 1578 )cpp"); 1579 // FIXME: Auto-completion in a template requires disabling delayed template 1580 // parsing. 1581 CDB.ExtraClangFlags.push_back("-fno-delayed-template-parsing"); 1582 runAddDocument(Server, FooCpp, Source.code(), WantDiagnostics::Yes); 1583 CodeCompleteResult Completions = cantFail(runCodeComplete( 1584 Server, FooCpp, Source.point(), clangd::CodeCompleteOptions())); 1585 1586 // We should not get any of those comments in completion. 1587 EXPECT_THAT( 1588 Completions.Completions, 1589 UnorderedElementsAre(AllOf(Not(IsDocumented()), Named("comments_foo")), 1590 AllOf(IsDocumented(), Named("comments_baz")), 1591 AllOf(IsDocumented(), Named("comments_quux")), 1592 AllOf(Not(IsDocumented()), Named("comments_ns")), 1593 // FIXME(ibiryukov): the following items should have 1594 // empty documentation, since they are separated from 1595 // a comment with an empty line. Unfortunately, I 1596 // couldn't make Sema tests pass if we ignore those. 1597 AllOf(IsDocumented(), Named("comments_bar")), 1598 AllOf(IsDocumented(), Named("comments_qux")))); 1599 } 1600 1601 TEST(CompletionTest, CompleteOnInvalidLine) { 1602 auto FooCpp = testPath("foo.cpp"); 1603 1604 MockCompilationDatabase CDB; 1605 IgnoreDiagnostics DiagConsumer; 1606 MockFSProvider FS; 1607 FS.Files[FooCpp] = "// empty file"; 1608 1609 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1610 // Run completion outside the file range. 1611 Position Pos; 1612 Pos.line = 100; 1613 Pos.character = 0; 1614 EXPECT_THAT_EXPECTED( 1615 runCodeComplete(Server, FooCpp, Pos, clangd::CodeCompleteOptions()), 1616 Failed()); 1617 } 1618 1619 TEST(CompletionTest, QualifiedNames) { 1620 auto Results = completions( 1621 R"cpp( 1622 namespace ns { int local; void both(); } 1623 void f() { ::ns::^ } 1624 )cpp", 1625 {func("ns::both"), cls("ns::Index")}); 1626 // We get results from both index and sema, with no duplicates. 1627 EXPECT_THAT( 1628 Results.Completions, 1629 UnorderedElementsAre(Scope("ns::"), Scope("ns::"), Scope("ns::"))); 1630 } 1631 1632 TEST(CompletionTest, Render) { 1633 CodeCompletion C; 1634 C.Name = "x"; 1635 C.Signature = "(bool) const"; 1636 C.SnippetSuffix = "(${0:bool})"; 1637 C.ReturnType = "int"; 1638 C.RequiredQualifier = "Foo::"; 1639 C.Scope = "ns::Foo::"; 1640 C.Documentation = "This is x()."; 1641 C.Includes.emplace_back(); 1642 auto &Include = C.Includes.back(); 1643 Include.Header = "\"foo.h\""; 1644 C.Kind = CompletionItemKind::Method; 1645 C.Score.Total = 1.0; 1646 C.Origin = SymbolOrigin::AST | SymbolOrigin::Static; 1647 1648 CodeCompleteOptions Opts; 1649 Opts.IncludeIndicator.Insert = "^"; 1650 Opts.IncludeIndicator.NoInsert = ""; 1651 Opts.EnableSnippets = false; 1652 1653 auto R = C.render(Opts); 1654 EXPECT_EQ(R.label, "Foo::x(bool) const"); 1655 EXPECT_EQ(R.insertText, "Foo::x"); 1656 EXPECT_EQ(R.insertTextFormat, InsertTextFormat::PlainText); 1657 EXPECT_EQ(R.filterText, "x"); 1658 EXPECT_EQ(R.detail, "int\n\"foo.h\""); 1659 EXPECT_EQ(R.documentation, "This is x()."); 1660 EXPECT_THAT(R.additionalTextEdits, IsEmpty()); 1661 EXPECT_EQ(R.sortText, sortText(1.0, "x")); 1662 EXPECT_FALSE(R.deprecated); 1663 1664 Opts.EnableSnippets = true; 1665 R = C.render(Opts); 1666 EXPECT_EQ(R.insertText, "Foo::x(${0:bool})"); 1667 EXPECT_EQ(R.insertTextFormat, InsertTextFormat::Snippet); 1668 1669 Include.Insertion.emplace(); 1670 R = C.render(Opts); 1671 EXPECT_EQ(R.label, "^Foo::x(bool) const"); 1672 EXPECT_THAT(R.additionalTextEdits, Not(IsEmpty())); 1673 1674 Opts.ShowOrigins = true; 1675 R = C.render(Opts); 1676 EXPECT_EQ(R.label, "^[AS]Foo::x(bool) const"); 1677 1678 C.BundleSize = 2; 1679 R = C.render(Opts); 1680 EXPECT_EQ(R.detail, "[2 overloads]\n\"foo.h\""); 1681 1682 C.Deprecated = true; 1683 R = C.render(Opts); 1684 EXPECT_TRUE(R.deprecated); 1685 } 1686 1687 TEST(CompletionTest, IgnoreRecoveryResults) { 1688 auto Results = completions( 1689 R"cpp( 1690 namespace ns { int NotRecovered() { return 0; } } 1691 void f() { 1692 // Sema enters recovery mode first and then normal mode. 1693 if (auto x = ns::NotRecover^) 1694 } 1695 )cpp"); 1696 EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("NotRecovered"))); 1697 } 1698 1699 TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) { 1700 auto Results = completions( 1701 R"cpp( 1702 namespace ns { 1703 class X { public: X(); int x_; }; 1704 X::X() : x_^(0) {} 1705 } 1706 )cpp"); 1707 EXPECT_THAT(Results.Completions, 1708 UnorderedElementsAre(AllOf(Scope("ns::X::"), Named("x_")))); 1709 } 1710 1711 TEST(CompletionTest, CodeCompletionContext) { 1712 auto Results = completions( 1713 R"cpp( 1714 namespace ns { 1715 class X { public: X(); int x_; }; 1716 void f() { 1717 X x; 1718 x.^; 1719 } 1720 } 1721 )cpp"); 1722 1723 EXPECT_THAT(Results.Context, CodeCompletionContext::CCC_DotMemberAccess); 1724 } 1725 1726 TEST(CompletionTest, FixItForArrowToDot) { 1727 MockFSProvider FS; 1728 MockCompilationDatabase CDB; 1729 IgnoreDiagnostics DiagConsumer; 1730 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1731 1732 CodeCompleteOptions Opts; 1733 Opts.IncludeFixIts = true; 1734 Annotations TestCode( 1735 R"cpp( 1736 class Auxilary { 1737 public: 1738 void AuxFunction(); 1739 }; 1740 class ClassWithPtr { 1741 public: 1742 void MemberFunction(); 1743 Auxilary* operator->() const; 1744 Auxilary* Aux; 1745 }; 1746 void f() { 1747 ClassWithPtr x; 1748 x[[->]]^; 1749 } 1750 )cpp"); 1751 auto Results = 1752 completions(Server, TestCode.code(), TestCode.point(), {}, Opts); 1753 EXPECT_EQ(Results.Completions.size(), 3u); 1754 1755 TextEdit ReplacementEdit; 1756 ReplacementEdit.range = TestCode.range(); 1757 ReplacementEdit.newText = "."; 1758 for (const auto &C : Results.Completions) { 1759 EXPECT_TRUE(C.FixIts.size() == 1u || C.Name == "AuxFunction"); 1760 if (!C.FixIts.empty()) { 1761 EXPECT_THAT(C.FixIts, ElementsAre(ReplacementEdit)); 1762 } 1763 } 1764 } 1765 1766 TEST(CompletionTest, FixItForDotToArrow) { 1767 MockFSProvider FS; 1768 MockCompilationDatabase CDB; 1769 IgnoreDiagnostics DiagConsumer; 1770 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1771 1772 CodeCompleteOptions Opts; 1773 Opts.IncludeFixIts = true; 1774 Annotations TestCode( 1775 R"cpp( 1776 class Auxilary { 1777 public: 1778 void AuxFunction(); 1779 }; 1780 class ClassWithPtr { 1781 public: 1782 void MemberFunction(); 1783 Auxilary* operator->() const; 1784 Auxilary* Aux; 1785 }; 1786 void f() { 1787 ClassWithPtr x; 1788 x[[.]]^; 1789 } 1790 )cpp"); 1791 auto Results = 1792 completions(Server, TestCode.code(), TestCode.point(), {}, Opts); 1793 EXPECT_EQ(Results.Completions.size(), 3u); 1794 1795 TextEdit ReplacementEdit; 1796 ReplacementEdit.range = TestCode.range(); 1797 ReplacementEdit.newText = "->"; 1798 for (const auto &C : Results.Completions) { 1799 EXPECT_TRUE(C.FixIts.empty() || C.Name == "AuxFunction"); 1800 if (!C.FixIts.empty()) { 1801 EXPECT_THAT(C.FixIts, ElementsAre(ReplacementEdit)); 1802 } 1803 } 1804 } 1805 1806 TEST(CompletionTest, RenderWithFixItMerged) { 1807 TextEdit FixIt; 1808 FixIt.range.end.character = 5; 1809 FixIt.newText = "->"; 1810 1811 CodeCompletion C; 1812 C.Name = "x"; 1813 C.RequiredQualifier = "Foo::"; 1814 C.FixIts = {FixIt}; 1815 C.CompletionTokenRange.start.character = 5; 1816 1817 CodeCompleteOptions Opts; 1818 Opts.IncludeFixIts = true; 1819 1820 auto R = C.render(Opts); 1821 EXPECT_TRUE(R.textEdit); 1822 EXPECT_EQ(R.textEdit->newText, "->Foo::x"); 1823 EXPECT_TRUE(R.additionalTextEdits.empty()); 1824 } 1825 1826 TEST(CompletionTest, RenderWithFixItNonMerged) { 1827 TextEdit FixIt; 1828 FixIt.range.end.character = 4; 1829 FixIt.newText = "->"; 1830 1831 CodeCompletion C; 1832 C.Name = "x"; 1833 C.RequiredQualifier = "Foo::"; 1834 C.FixIts = {FixIt}; 1835 C.CompletionTokenRange.start.character = 5; 1836 1837 CodeCompleteOptions Opts; 1838 Opts.IncludeFixIts = true; 1839 1840 auto R = C.render(Opts); 1841 EXPECT_TRUE(R.textEdit); 1842 EXPECT_EQ(R.textEdit->newText, "Foo::x"); 1843 EXPECT_THAT(R.additionalTextEdits, UnorderedElementsAre(FixIt)); 1844 } 1845 1846 TEST(CompletionTest, CompletionTokenRange) { 1847 MockFSProvider FS; 1848 MockCompilationDatabase CDB; 1849 IgnoreDiagnostics DiagConsumer; 1850 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 1851 1852 constexpr const char *TestCodes[] = { 1853 R"cpp( 1854 class Auxilary { 1855 public: 1856 void AuxFunction(); 1857 }; 1858 void f() { 1859 Auxilary x; 1860 x.[[Aux]]^; 1861 } 1862 )cpp", 1863 R"cpp( 1864 class Auxilary { 1865 public: 1866 void AuxFunction(); 1867 }; 1868 void f() { 1869 Auxilary x; 1870 x.[[]]^; 1871 } 1872 )cpp"}; 1873 for (const auto &Text : TestCodes) { 1874 Annotations TestCode(Text); 1875 auto Results = completions(Server, TestCode.code(), TestCode.point()); 1876 1877 if (Results.Completions.size() != 1) { 1878 ADD_FAILURE() << "Results.Completions.size() != 1"; 1879 continue; 1880 } 1881 EXPECT_THAT(Results.Completions.front().CompletionTokenRange, 1882 TestCode.range()); 1883 } 1884 } 1885 1886 TEST(SignatureHelpTest, OverloadsOrdering) { 1887 const auto Results = signatures(R"cpp( 1888 void foo(int x); 1889 void foo(int x, float y); 1890 void foo(float x, int y); 1891 void foo(float x, float y); 1892 void foo(int x, int y = 0); 1893 int main() { foo(^); } 1894 )cpp"); 1895 EXPECT_THAT(Results.signatures, 1896 ElementsAre(Sig("foo([[int x]]) -> void"), 1897 Sig("foo([[int x]], [[int y = 0]]) -> void"), 1898 Sig("foo([[float x]], [[int y]]) -> void"), 1899 Sig("foo([[int x]], [[float y]]) -> void"), 1900 Sig("foo([[float x]], [[float y]]) -> void"))); 1901 // We always prefer the first signature. 1902 EXPECT_EQ(0, Results.activeSignature); 1903 EXPECT_EQ(0, Results.activeParameter); 1904 } 1905 1906 TEST(SignatureHelpTest, InstantiatedSignatures) { 1907 StringRef Sig0 = R"cpp( 1908 template <class T> 1909 void foo(T, T, T); 1910 1911 int main() { 1912 foo<int>(^); 1913 } 1914 )cpp"; 1915 1916 EXPECT_THAT(signatures(Sig0).signatures, 1917 ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void"))); 1918 1919 StringRef Sig1 = R"cpp( 1920 template <class T> 1921 void foo(T, T, T); 1922 1923 int main() { 1924 foo(10, ^); 1925 })cpp"; 1926 1927 EXPECT_THAT(signatures(Sig1).signatures, 1928 ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void"))); 1929 1930 StringRef Sig2 = R"cpp( 1931 template <class ...T> 1932 void foo(T...); 1933 1934 int main() { 1935 foo<int>(^); 1936 } 1937 )cpp"; 1938 1939 EXPECT_THAT(signatures(Sig2).signatures, 1940 ElementsAre(Sig("foo([[T...]]) -> void"))); 1941 1942 // It is debatable whether we should substitute the outer template parameter 1943 // ('T') in that case. Currently we don't substitute it in signature help, but 1944 // do substitute in code complete. 1945 // FIXME: make code complete and signature help consistent, figure out which 1946 // way is better. 1947 StringRef Sig3 = R"cpp( 1948 template <class T> 1949 struct X { 1950 template <class U> 1951 void foo(T, U); 1952 }; 1953 1954 int main() { 1955 X<int>().foo<double>(^) 1956 } 1957 )cpp"; 1958 1959 EXPECT_THAT(signatures(Sig3).signatures, 1960 ElementsAre(Sig("foo([[T]], [[U]]) -> void"))); 1961 } 1962 1963 TEST(SignatureHelpTest, IndexDocumentation) { 1964 Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#"); 1965 Foo0.Documentation = "Doc from the index"; 1966 Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#"); 1967 Foo1.Documentation = "Doc from the index"; 1968 Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#"); 1969 1970 StringRef Sig0 = R"cpp( 1971 int foo(); 1972 int foo(double); 1973 1974 void test() { 1975 foo(^); 1976 } 1977 )cpp"; 1978 1979 EXPECT_THAT( 1980 signatures(Sig0, {Foo0}).signatures, 1981 ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")), 1982 AllOf(Sig("foo([[double]]) -> int"), SigDoc("")))); 1983 1984 StringRef Sig1 = R"cpp( 1985 int foo(); 1986 // Overriden doc from sema 1987 int foo(int); 1988 // Doc from sema 1989 int foo(int, int); 1990 1991 void test() { 1992 foo(^); 1993 } 1994 )cpp"; 1995 1996 EXPECT_THAT( 1997 signatures(Sig1, {Foo0, Foo1, Foo2}).signatures, 1998 ElementsAre( 1999 AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")), 2000 AllOf(Sig("foo([[int]]) -> int"), SigDoc("Overriden doc from sema")), 2001 AllOf(Sig("foo([[int]], [[int]]) -> int"), SigDoc("Doc from sema")))); 2002 } 2003 2004 TEST(SignatureHelpTest, DynamicIndexDocumentation) { 2005 MockFSProvider FS; 2006 MockCompilationDatabase CDB; 2007 IgnoreDiagnostics DiagConsumer; 2008 ClangdServer::Options Opts = ClangdServer::optsForTest(); 2009 Opts.BuildDynamicSymbolIndex = true; 2010 ClangdServer Server(CDB, FS, DiagConsumer, Opts); 2011 2012 FS.Files[testPath("foo.h")] = R"cpp( 2013 struct Foo { 2014 // Member doc 2015 int foo(); 2016 }; 2017 )cpp"; 2018 Annotations FileContent(R"cpp( 2019 #include "foo.h" 2020 void test() { 2021 Foo f; 2022 f.foo(^); 2023 } 2024 )cpp"); 2025 auto File = testPath("test.cpp"); 2026 Server.addDocument(File, FileContent.code()); 2027 // Wait for the dynamic index being built. 2028 ASSERT_TRUE(Server.blockUntilIdleForTest()); 2029 EXPECT_THAT( 2030 llvm::cantFail(runSignatureHelp(Server, File, FileContent.point())) 2031 .signatures, 2032 ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc")))); 2033 } 2034 2035 TEST(CompletionTest, CompletionFunctionArgsDisabled) { 2036 CodeCompleteOptions Opts; 2037 Opts.EnableSnippets = true; 2038 Opts.EnableFunctionArgSnippets = false; 2039 2040 { 2041 auto Results = completions( 2042 R"cpp( 2043 void xfoo(); 2044 void xfoo(int x, int y); 2045 void f() { xfo^ })cpp", 2046 {}, Opts); 2047 EXPECT_THAT( 2048 Results.Completions, 2049 UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("()")), 2050 AllOf(Named("xfoo"), SnippetSuffix("($0)")))); 2051 } 2052 { 2053 auto Results = completions( 2054 R"cpp( 2055 void xbar(); 2056 void f() { xba^ })cpp", 2057 {}, Opts); 2058 EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf( 2059 Named("xbar"), SnippetSuffix("()")))); 2060 } 2061 { 2062 Opts.BundleOverloads = true; 2063 auto Results = completions( 2064 R"cpp( 2065 void xfoo(); 2066 void xfoo(int x, int y); 2067 void f() { xfo^ })cpp", 2068 {}, Opts); 2069 EXPECT_THAT( 2070 Results.Completions, 2071 UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("($0)")))); 2072 } 2073 { 2074 auto Results = completions( 2075 R"cpp( 2076 template <class T, class U> 2077 void xfoo(int a, U b); 2078 void f() { xfo^ })cpp", 2079 {}, Opts); 2080 EXPECT_THAT( 2081 Results.Completions, 2082 UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("<$1>($0)")))); 2083 } 2084 { 2085 auto Results = completions( 2086 R"cpp( 2087 template <class T> 2088 class foo_class{}; 2089 template <class T> 2090 using foo_alias = T**; 2091 void f() { foo_^ })cpp", 2092 {}, Opts); 2093 EXPECT_THAT( 2094 Results.Completions, 2095 UnorderedElementsAre(AllOf(Named("foo_class"), SnippetSuffix("<$0>")), 2096 AllOf(Named("foo_alias"), SnippetSuffix("<$0>")))); 2097 } 2098 } 2099 2100 TEST(CompletionTest, SuggestOverrides) { 2101 constexpr const char *const Text(R"cpp( 2102 class A { 2103 public: 2104 virtual void vfunc(bool param); 2105 virtual void vfunc(bool param, int p); 2106 void func(bool param); 2107 }; 2108 class B : public A { 2109 virtual void ttt(bool param) const; 2110 void vfunc(bool param, int p) override; 2111 }; 2112 class C : public B { 2113 public: 2114 void vfunc(bool param) override; 2115 ^ 2116 }; 2117 )cpp"); 2118 const auto Results = completions(Text); 2119 EXPECT_THAT( 2120 Results.Completions, 2121 AllOf(Contains(AllOf(Labeled("void vfunc(bool param, int p) override"), 2122 NameStartsWith("vfunc"))), 2123 Contains(AllOf(Labeled("void ttt(bool param) const override"), 2124 NameStartsWith("ttt"))), 2125 Not(Contains(Labeled("void vfunc(bool param) override"))))); 2126 } 2127 2128 TEST(CompletionTest, OverridesNonIdentName) { 2129 // Check the completions call does not crash. 2130 completions(R"cpp( 2131 struct Base { 2132 virtual ~Base() = 0; 2133 virtual operator int() = 0; 2134 virtual Base& operator+(Base&) = 0; 2135 }; 2136 2137 struct Derived : Base { 2138 ^ 2139 }; 2140 )cpp"); 2141 } 2142 2143 TEST(GuessCompletionPrefix, Filters) { 2144 for (llvm::StringRef Case : { 2145 "[[scope::]][[ident]]^", 2146 "[[]][[]]^", 2147 "\n[[]][[]]^", 2148 "[[]][[ab]]^", 2149 "x.[[]][[ab]]^", 2150 "x.[[]][[]]^", 2151 "[[x::]][[ab]]^", 2152 "[[x::]][[]]^", 2153 "[[::x::]][[ab]]^", 2154 "some text [[scope::more::]][[identif]]^ier", 2155 "some text [[scope::]][[mor]]^e::identifier", 2156 "weird case foo::[[::bar::]][[baz]]^", 2157 }) { 2158 Annotations F(Case); 2159 auto Offset = cantFail(positionToOffset(F.code(), F.point())); 2160 auto ToStringRef = [&](Range R) { 2161 return F.code().slice(cantFail(positionToOffset(F.code(), R.start)), 2162 cantFail(positionToOffset(F.code(), R.end))); 2163 }; 2164 auto WantQualifier = ToStringRef(F.ranges()[0]), 2165 WantName = ToStringRef(F.ranges()[1]); 2166 2167 auto Prefix = guessCompletionPrefix(F.code(), Offset); 2168 // Even when components are empty, check their offsets are correct. 2169 EXPECT_EQ(WantQualifier, Prefix.Qualifier) << Case; 2170 EXPECT_EQ(WantQualifier.begin(), Prefix.Qualifier.begin()) << Case; 2171 EXPECT_EQ(WantName, Prefix.Name) << Case; 2172 EXPECT_EQ(WantName.begin(), Prefix.Name.begin()) << Case; 2173 } 2174 } 2175 2176 TEST(CompletionTest, EnableSpeculativeIndexRequest) { 2177 MockFSProvider FS; 2178 MockCompilationDatabase CDB; 2179 IgnoreDiagnostics DiagConsumer; 2180 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 2181 2182 auto File = testPath("foo.cpp"); 2183 Annotations Test(R"cpp( 2184 namespace ns1 { int abc; } 2185 namespace ns2 { int abc; } 2186 void f() { ns1::ab$1^; ns1::ab$2^; } 2187 void f2() { ns2::ab$3^; } 2188 )cpp"); 2189 runAddDocument(Server, File, Test.code()); 2190 clangd::CodeCompleteOptions Opts = {}; 2191 2192 IndexRequestCollector Requests; 2193 Opts.Index = &Requests; 2194 Opts.SpeculativeIndexRequest = true; 2195 2196 auto CompleteAtPoint = [&](StringRef P) { 2197 cantFail(runCodeComplete(Server, File, Test.point(P), Opts)); 2198 }; 2199 2200 CompleteAtPoint("1"); 2201 auto Reqs1 = Requests.consumeRequests(1); 2202 ASSERT_EQ(Reqs1.size(), 1u); 2203 EXPECT_THAT(Reqs1[0].Scopes, UnorderedElementsAre("ns1::")); 2204 2205 CompleteAtPoint("2"); 2206 auto Reqs2 = Requests.consumeRequests(1); 2207 // Speculation succeeded. Used speculative index result. 2208 ASSERT_EQ(Reqs2.size(), 1u); 2209 EXPECT_EQ(Reqs2[0], Reqs1[0]); 2210 2211 CompleteAtPoint("3"); 2212 // Speculation failed. Sent speculative index request and the new index 2213 // request after sema. 2214 auto Reqs3 = Requests.consumeRequests(2); 2215 ASSERT_EQ(Reqs3.size(), 2u); 2216 } 2217 2218 TEST(CompletionTest, InsertTheMostPopularHeader) { 2219 std::string DeclFile = URI::create(testPath("foo")).toString(); 2220 Symbol Sym = func("Func"); 2221 Sym.CanonicalDeclaration.FileURI = DeclFile.c_str(); 2222 Sym.IncludeHeaders.emplace_back("\"foo.h\"", 2); 2223 Sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000); 2224 2225 auto Results = completions("Fun^", {Sym}).Completions; 2226 assert(!Results.empty()); 2227 EXPECT_THAT(Results[0], AllOf(Named("Func"), InsertInclude("\"bar.h\""))); 2228 EXPECT_EQ(Results[0].Includes.size(), 2u); 2229 } 2230 2231 TEST(CompletionTest, NoInsertIncludeIfOnePresent) { 2232 MockFSProvider FS; 2233 MockCompilationDatabase CDB; 2234 2235 std::string FooHeader = testPath("foo.h"); 2236 FS.Files[FooHeader] = ""; 2237 2238 IgnoreDiagnostics DiagConsumer; 2239 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 2240 2241 std::string DeclFile = URI::create(testPath("foo")).toString(); 2242 Symbol Sym = func("Func"); 2243 Sym.CanonicalDeclaration.FileURI = DeclFile.c_str(); 2244 Sym.IncludeHeaders.emplace_back("\"foo.h\"", 2); 2245 Sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000); 2246 2247 EXPECT_THAT( 2248 completions(Server, "#include \"foo.h\"\nFun^", {Sym}).Completions, 2249 UnorderedElementsAre( 2250 AllOf(Named("Func"), HasInclude("\"foo.h\""), Not(InsertInclude())))); 2251 } 2252 2253 TEST(CompletionTest, MergeMacrosFromIndexAndSema) { 2254 Symbol Sym; 2255 Sym.Name = "Clangd_Macro_Test"; 2256 Sym.ID = SymbolID("c:foo.cpp@8@macro@Clangd_Macro_Test"); 2257 Sym.SymInfo.Kind = index::SymbolKind::Macro; 2258 Sym.Flags |= Symbol::IndexedForCodeCompletion; 2259 EXPECT_THAT(completions("#define Clangd_Macro_Test\nClangd_Macro_T^", {Sym}) 2260 .Completions, 2261 UnorderedElementsAre(Named("Clangd_Macro_Test"))); 2262 } 2263 2264 TEST(CompletionTest, MacroFromPreamble) { 2265 MockFSProvider FS; 2266 MockCompilationDatabase CDB; 2267 std::string FooHeader = testPath("foo.h"); 2268 FS.Files[FooHeader] = "#define CLANGD_PREAMBLE_HEADER x\n"; 2269 IgnoreDiagnostics DiagConsumer; 2270 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 2271 auto Results = completions( 2272 R"cpp(#include "foo.h" 2273 #define CLANGD_PREAMBLE_MAIN x 2274 2275 int x = 0; 2276 #define CLANGD_MAIN x 2277 void f() { CLANGD_^ } 2278 )cpp", 2279 {func("CLANGD_INDEX")}); 2280 // We should get results from the main file, including the preamble section. 2281 // However no results from included files (the index should cover them). 2282 EXPECT_THAT(Results.Completions, 2283 UnorderedElementsAre(Named("CLANGD_PREAMBLE_MAIN"), 2284 Named("CLANGD_MAIN"), 2285 Named("CLANGD_INDEX"))); 2286 } 2287 2288 TEST(CompletionTest, DeprecatedResults) { 2289 std::string Body = R"cpp( 2290 void TestClangd(); 2291 void TestClangc() __attribute__((deprecated("", ""))); 2292 )cpp"; 2293 2294 EXPECT_THAT( 2295 completions(Body + "int main() { TestClang^ }").Completions, 2296 UnorderedElementsAre(AllOf(Named("TestClangd"), Not(Deprecated())), 2297 AllOf(Named("TestClangc"), Deprecated()))); 2298 } 2299 2300 TEST(SignatureHelpTest, InsideArgument) { 2301 { 2302 const auto Results = signatures(R"cpp( 2303 void foo(int x); 2304 void foo(int x, int y); 2305 int main() { foo(1+^); } 2306 )cpp"); 2307 EXPECT_THAT(Results.signatures, 2308 ElementsAre(Sig("foo([[int x]]) -> void"), 2309 Sig("foo([[int x]], [[int y]]) -> void"))); 2310 EXPECT_EQ(0, Results.activeParameter); 2311 } 2312 { 2313 const auto Results = signatures(R"cpp( 2314 void foo(int x); 2315 void foo(int x, int y); 2316 int main() { foo(1^); } 2317 )cpp"); 2318 EXPECT_THAT(Results.signatures, 2319 ElementsAre(Sig("foo([[int x]]) -> void"), 2320 Sig("foo([[int x]], [[int y]]) -> void"))); 2321 EXPECT_EQ(0, Results.activeParameter); 2322 } 2323 { 2324 const auto Results = signatures(R"cpp( 2325 void foo(int x); 2326 void foo(int x, int y); 2327 int main() { foo(1^0); } 2328 )cpp"); 2329 EXPECT_THAT(Results.signatures, 2330 ElementsAre(Sig("foo([[int x]]) -> void"), 2331 Sig("foo([[int x]], [[int y]]) -> void"))); 2332 EXPECT_EQ(0, Results.activeParameter); 2333 } 2334 { 2335 const auto Results = signatures(R"cpp( 2336 void foo(int x); 2337 void foo(int x, int y); 2338 int bar(int x, int y); 2339 int main() { bar(foo(2, 3^)); } 2340 )cpp"); 2341 EXPECT_THAT(Results.signatures, 2342 ElementsAre(Sig("foo([[int x]], [[int y]]) -> void"))); 2343 EXPECT_EQ(1, Results.activeParameter); 2344 } 2345 } 2346 2347 TEST(SignatureHelpTest, ConstructorInitializeFields) { 2348 { 2349 const auto Results = signatures(R"cpp( 2350 struct A { 2351 A(int); 2352 }; 2353 struct B { 2354 B() : a_elem(^) {} 2355 A a_elem; 2356 }; 2357 )cpp"); 2358 EXPECT_THAT(Results.signatures, 2359 UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"), 2360 Sig("A([[const A &]])"))); 2361 } 2362 { 2363 const auto Results = signatures(R"cpp( 2364 struct A { 2365 A(int); 2366 }; 2367 struct C { 2368 C(int); 2369 C(A); 2370 }; 2371 struct B { 2372 B() : c_elem(A(1^)) {} 2373 C c_elem; 2374 }; 2375 )cpp"); 2376 EXPECT_THAT(Results.signatures, 2377 UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"), 2378 Sig("A([[const A &]])"))); 2379 } 2380 } 2381 2382 TEST(CompletionTest, IncludedCompletionKinds) { 2383 MockFSProvider FS; 2384 MockCompilationDatabase CDB; 2385 std::string Subdir = testPath("sub"); 2386 std::string SearchDirArg = (Twine("-I") + Subdir).str(); 2387 CDB.ExtraClangFlags = {SearchDirArg.c_str()}; 2388 std::string BarHeader = testPath("sub/bar.h"); 2389 FS.Files[BarHeader] = ""; 2390 IgnoreDiagnostics DiagConsumer; 2391 ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest()); 2392 auto Results = completions(Server, 2393 R"cpp( 2394 #include "^" 2395 )cpp"); 2396 EXPECT_THAT(Results.Completions, 2397 AllOf(Has("sub/", CompletionItemKind::Folder), 2398 Has("bar.h\"", CompletionItemKind::File))); 2399 } 2400 2401 TEST(CompletionTest, NoCrashAtNonAlphaIncludeHeader) { 2402 auto Results = completions( 2403 R"cpp( 2404 #include "./^" 2405 )cpp"); 2406 EXPECT_TRUE(Results.Completions.empty()); 2407 } 2408 2409 TEST(CompletionTest, NoAllScopesCompletionWhenQualified) { 2410 clangd::CodeCompleteOptions Opts = {}; 2411 Opts.AllScopes = true; 2412 2413 auto Results = completions( 2414 R"cpp( 2415 void f() { na::Clangd^ } 2416 )cpp", 2417 {cls("na::ClangdA"), cls("nx::ClangdX"), cls("Clangd3")}, Opts); 2418 EXPECT_THAT(Results.Completions, 2419 UnorderedElementsAre( 2420 AllOf(Qualifier(""), Scope("na::"), Named("ClangdA")))); 2421 } 2422 2423 TEST(CompletionTest, AllScopesCompletion) { 2424 clangd::CodeCompleteOptions Opts = {}; 2425 Opts.AllScopes = true; 2426 2427 auto Results = completions( 2428 R"cpp( 2429 namespace na { 2430 void f() { Clangd^ } 2431 } 2432 )cpp", 2433 {cls("nx::Clangd1"), cls("ny::Clangd2"), cls("Clangd3"), 2434 cls("na::nb::Clangd4")}, 2435 Opts); 2436 EXPECT_THAT( 2437 Results.Completions, 2438 UnorderedElementsAre(AllOf(Qualifier("nx::"), Named("Clangd1")), 2439 AllOf(Qualifier("ny::"), Named("Clangd2")), 2440 AllOf(Qualifier(""), Scope(""), Named("Clangd3")), 2441 AllOf(Qualifier("nb::"), Named("Clangd4")))); 2442 } 2443 2444 TEST(CompletionTest, NoQualifierIfShadowed) { 2445 clangd::CodeCompleteOptions Opts = {}; 2446 Opts.AllScopes = true; 2447 2448 auto Results = completions(R"cpp( 2449 namespace nx { class Clangd1 {}; } 2450 using nx::Clangd1; 2451 void f() { Clangd^ } 2452 )cpp", 2453 {cls("nx::Clangd1"), cls("nx::Clangd2")}, Opts); 2454 // Although Clangd1 is from another namespace, Sema tells us it's in-scope and 2455 // needs no qualifier. 2456 EXPECT_THAT(Results.Completions, 2457 UnorderedElementsAre(AllOf(Qualifier(""), Named("Clangd1")), 2458 AllOf(Qualifier("nx::"), Named("Clangd2")))); 2459 } 2460 2461 TEST(CompletionTest, NoCompletionsForNewNames) { 2462 clangd::CodeCompleteOptions Opts; 2463 Opts.AllScopes = true; 2464 auto Results = completions(R"cpp( 2465 void f() { int n^ } 2466 )cpp", 2467 {cls("naber"), cls("nx::naber")}, Opts); 2468 EXPECT_THAT(Results.Completions, UnorderedElementsAre()); 2469 } 2470 2471 TEST(CompletionTest, Lambda) { 2472 clangd::CodeCompleteOptions Opts = {}; 2473 2474 auto Results = completions(R"cpp( 2475 void function() { 2476 auto Lambda = [](int a, const double &b) {return 1.f;}; 2477 Lam^ 2478 } 2479 )cpp", 2480 {}, Opts); 2481 2482 ASSERT_EQ(Results.Completions.size(), 1u); 2483 const auto &A = Results.Completions.front(); 2484 EXPECT_EQ(A.Name, "Lambda"); 2485 EXPECT_EQ(A.Signature, "(int a, const double &b) const"); 2486 EXPECT_EQ(A.Kind, CompletionItemKind::Variable); 2487 EXPECT_EQ(A.ReturnType, "float"); 2488 EXPECT_EQ(A.SnippetSuffix, "(${1:int a}, ${2:const double &b})"); 2489 } 2490 2491 TEST(CompletionTest, ObjectiveCMethodNoArguments) { 2492 auto Results = completions(R"objc( 2493 @interface Foo 2494 @property(nonatomic, setter=setXToIgnoreComplete:) int value; 2495 @end 2496 Foo *foo = [Foo new]; int y = [foo v^] 2497 )objc", 2498 /*IndexSymbols=*/{}, 2499 /*Opts=*/{}, "Foo.m"); 2500 2501 auto C = Results.Completions; 2502 EXPECT_THAT(C, ElementsAre(Named("value"))); 2503 EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method))); 2504 EXPECT_THAT(C, ElementsAre(ReturnType("int"))); 2505 EXPECT_THAT(C, ElementsAre(Signature(""))); 2506 EXPECT_THAT(C, ElementsAre(SnippetSuffix(""))); 2507 } 2508 2509 TEST(CompletionTest, ObjectiveCMethodOneArgument) { 2510 auto Results = completions(R"objc( 2511 @interface Foo 2512 - (int)valueForCharacter:(char)c; 2513 @end 2514 Foo *foo = [Foo new]; int y = [foo v^] 2515 )objc", 2516 /*IndexSymbols=*/{}, 2517 /*Opts=*/{}, "Foo.m"); 2518 2519 auto C = Results.Completions; 2520 EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:"))); 2521 EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method))); 2522 EXPECT_THAT(C, ElementsAre(ReturnType("int"))); 2523 EXPECT_THAT(C, ElementsAre(Signature("(char)"))); 2524 EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(char)}"))); 2525 } 2526 2527 TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) { 2528 auto Results = completions(R"objc( 2529 @interface Foo 2530 + (id)fooWithValue:(int)value fooey:(unsigned int)fooey; 2531 @end 2532 id val = [Foo foo^] 2533 )objc", 2534 /*IndexSymbols=*/{}, 2535 /*Opts=*/{}, "Foo.m"); 2536 2537 auto C = Results.Completions; 2538 EXPECT_THAT(C, ElementsAre(Named("fooWithValue:"))); 2539 EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method))); 2540 EXPECT_THAT(C, ElementsAre(ReturnType("id"))); 2541 EXPECT_THAT(C, ElementsAre(Signature("(int) fooey:(unsigned int)"))); 2542 EXPECT_THAT( 2543 C, ElementsAre(SnippetSuffix("${1:(int)} fooey:${2:(unsigned int)}"))); 2544 } 2545 2546 TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) { 2547 auto Results = completions(R"objc( 2548 @interface Foo 2549 + (id)fooWithValue:(int)value fooey:(unsigned int)fooey; 2550 @end 2551 id val = [Foo fooWithValue:10 f^] 2552 )objc", 2553 /*IndexSymbols=*/{}, 2554 /*Opts=*/{}, "Foo.m"); 2555 2556 auto C = Results.Completions; 2557 EXPECT_THAT(C, ElementsAre(Named("fooey:"))); 2558 EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method))); 2559 EXPECT_THAT(C, ElementsAre(ReturnType("id"))); 2560 EXPECT_THAT(C, ElementsAre(Signature("(unsigned int)"))); 2561 EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(unsigned int)}"))); 2562 } 2563 2564 TEST(CompletionTest, CursorInSnippets) { 2565 clangd::CodeCompleteOptions Options; 2566 Options.EnableSnippets = true; 2567 auto Results = completions( 2568 R"cpp( 2569 void while_foo(int a, int b); 2570 void test() { 2571 whil^ 2572 })cpp", 2573 /*IndexSymbols=*/{}, Options); 2574 2575 // Last placeholder in code patterns should be $0 to put the cursor there. 2576 EXPECT_THAT(Results.Completions, 2577 Contains(AllOf( 2578 Named("while"), 2579 SnippetSuffix(" (${1:condition}) {\n${0:statements}\n}")))); 2580 // However, snippets for functions must *not* end with $0. 2581 EXPECT_THAT(Results.Completions, 2582 Contains(AllOf(Named("while_foo"), 2583 SnippetSuffix("(${1:int a}, ${2:int b})")))); 2584 } 2585 2586 TEST(CompletionTest, WorksWithNullType) { 2587 auto R = completions(R"cpp( 2588 int main() { 2589 for (auto [loopVar] : y ) { // y has to be unresolved. 2590 int z = loopV^; 2591 } 2592 } 2593 )cpp"); 2594 EXPECT_THAT(R.Completions, ElementsAre(Named("loopVar"))); 2595 } 2596 2597 TEST(CompletionTest, UsingDecl) { 2598 const char *Header(R"cpp( 2599 void foo(int); 2600 namespace std { 2601 using ::foo; 2602 })cpp"); 2603 const char *Source(R"cpp( 2604 void bar() { 2605 std::^; 2606 })cpp"); 2607 auto Index = TestTU::withHeaderCode(Header).index(); 2608 clangd::CodeCompleteOptions Opts; 2609 Opts.Index = Index.get(); 2610 Opts.AllScopes = true; 2611 auto R = completions(Source, {}, Opts); 2612 EXPECT_THAT(R.Completions, 2613 ElementsAre(AllOf(Scope("std::"), Named("foo"), 2614 Kind(CompletionItemKind::Reference)))); 2615 } 2616 2617 TEST(CompletionTest, ScopeIsUnresolved) { 2618 clangd::CodeCompleteOptions Opts = {}; 2619 Opts.AllScopes = true; 2620 2621 auto Results = completions(R"cpp( 2622 namespace a { 2623 void f() { b::X^ } 2624 } 2625 )cpp", 2626 {cls("a::b::XYZ")}, Opts); 2627 EXPECT_THAT(Results.Completions, 2628 UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ")))); 2629 } 2630 2631 TEST(CompletionTest, NestedScopeIsUnresolved) { 2632 clangd::CodeCompleteOptions Opts = {}; 2633 Opts.AllScopes = true; 2634 2635 auto Results = completions(R"cpp( 2636 namespace a { 2637 namespace b {} 2638 void f() { b::c::X^ } 2639 } 2640 )cpp", 2641 {cls("a::b::c::XYZ")}, Opts); 2642 EXPECT_THAT(Results.Completions, 2643 UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ")))); 2644 } 2645 2646 // Clang parser gets confused here and doesn't report the ns:: prefix. 2647 // Naive behavior is to insert it again. We examine the source and recover. 2648 TEST(CompletionTest, NamespaceDoubleInsertion) { 2649 clangd::CodeCompleteOptions Opts = {}; 2650 2651 auto Results = completions(R"cpp( 2652 namespace foo { 2653 namespace ns {} 2654 #define M(X) < X 2655 M(ns::ABC^ 2656 } 2657 )cpp", 2658 {cls("foo::ns::ABCDE")}, Opts); 2659 EXPECT_THAT(Results.Completions, 2660 UnorderedElementsAre(AllOf(Qualifier(""), Named("ABCDE")))); 2661 } 2662 2663 TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) { 2664 // Despite the fact that base method matches the ref-qualifier better, 2665 // completion results should only include the derived method. 2666 auto Completions = completions(R"cpp( 2667 struct deque_base { 2668 float size(); 2669 double size() const; 2670 }; 2671 struct deque : deque_base { 2672 int size() const; 2673 }; 2674 2675 auto x = deque().^ 2676 )cpp") 2677 .Completions; 2678 EXPECT_THAT(Completions, 2679 ElementsAre(AllOf(ReturnType("int"), Named("size")))); 2680 } 2681 2682 TEST(NoCompileCompletionTest, Basic) { 2683 auto Results = completionsNoCompile(R"cpp( 2684 void func() { 2685 int xyz; 2686 int abc; 2687 ^ 2688 } 2689 )cpp"); 2690 EXPECT_FALSE(Results.RanParser); 2691 EXPECT_THAT(Results.Completions, 2692 UnorderedElementsAre(Named("void"), Named("func"), Named("int"), 2693 Named("xyz"), Named("abc"))); 2694 } 2695 2696 TEST(NoCompileCompletionTest, WithFilter) { 2697 auto Results = completionsNoCompile(R"cpp( 2698 void func() { 2699 int sym1; 2700 int sym2; 2701 int xyz1; 2702 int xyz2; 2703 sy^ 2704 } 2705 )cpp"); 2706 EXPECT_THAT(Results.Completions, 2707 UnorderedElementsAre(Named("sym1"), Named("sym2"))); 2708 } 2709 2710 TEST(NoCompileCompletionTest, WithIndex) { 2711 std::vector<Symbol> Syms = {func("xxx"), func("a::xxx"), func("ns::b::xxx"), 2712 func("c::xxx"), func("ns::d::xxx")}; 2713 auto Results = completionsNoCompile( 2714 R"cpp( 2715 // Current-scopes, unqualified completion. 2716 using namespace a; 2717 namespace ns { 2718 using namespace b; 2719 void foo() { 2720 xx^ 2721 } 2722 } 2723 )cpp", 2724 Syms); 2725 EXPECT_THAT(Results.Completions, 2726 UnorderedElementsAre(AllOf(Qualifier(""), Scope("")), 2727 AllOf(Qualifier(""), Scope("a::")), 2728 AllOf(Qualifier(""), Scope("ns::b::")))); 2729 CodeCompleteOptions Opts; 2730 Opts.AllScopes = true; 2731 Results = completionsNoCompile( 2732 R"cpp( 2733 // All-scopes unqualified completion. 2734 using namespace a; 2735 namespace ns { 2736 using namespace b; 2737 void foo() { 2738 xx^ 2739 } 2740 } 2741 )cpp", 2742 Syms, Opts); 2743 EXPECT_THAT(Results.Completions, 2744 UnorderedElementsAre(AllOf(Qualifier(""), Scope("")), 2745 AllOf(Qualifier(""), Scope("a::")), 2746 AllOf(Qualifier(""), Scope("ns::b::")), 2747 AllOf(Qualifier("c::"), Scope("c::")), 2748 AllOf(Qualifier("d::"), Scope("ns::d::")))); 2749 Results = completionsNoCompile( 2750 R"cpp( 2751 // Qualified completion. 2752 using namespace a; 2753 namespace ns { 2754 using namespace b; 2755 void foo() { 2756 b::xx^ 2757 } 2758 } 2759 )cpp", 2760 Syms, Opts); 2761 EXPECT_THAT(Results.Completions, 2762 ElementsAre(AllOf(Qualifier(""), Scope("ns::b::")))); 2763 Results = completionsNoCompile( 2764 R"cpp( 2765 // Absolutely qualified completion. 2766 using namespace a; 2767 namespace ns { 2768 using namespace b; 2769 void foo() { 2770 ::a::xx^ 2771 } 2772 } 2773 )cpp", 2774 Syms, Opts); 2775 EXPECT_THAT(Results.Completions, 2776 ElementsAre(AllOf(Qualifier(""), Scope("a::")))); 2777 } 2778 2779 } // namespace 2780 } // namespace clangd 2781 } // namespace clang 2782